mikkole

How to integrate BizTalk Server 2013 with Service Bus for Windows Server using SAS for authorization

MikkoLe — Wed, 21 Jan 2015 05:27:00 GMT

There is a great article by Paolo Salvatori about integrating BizTalk Server with Service Bus for Windows Server (the on-premises version). You can find the article from here:
https://code.msdn.microsoft.com/windowsapps/How-to-integrate-BizTalk-07fada58
However, it does not talk about how to use Shared Access Signatures (SAS) for authorization.

Let us assume that you have a Service Bus topic and subscription set up with SAS authorization. In addition, you have deployed an orchestration to BizTalk, which can process messages available in the subscription. Now you just need to know how to connect these dots, which basically means setting up a Receive Location.

The problem is that when Service Bus is configured to use SAS, SB-Messaging adapter in BizTalk Server 2013 cannot be used, as there is no way to configure the SAS key (by the way, SB-Messaging adapter in BizTalk Server 2013 R2 does support this, so first you should consider upgrading to the newest version). Therefore, WCF-Custom adapter has to be used and few custom endpoint behaviors need to implemented to enable the integration.

Create ListenUriEndpointBehavior

You have to specify the URL of the Service Bus topic as the address for WCF-Custom adapter. There is no place to set the actual URL of the subscription where the messages are read. Therefore, we need a custom endpoint behavior to set it at runtime.

You can use Paolo's example for implementing this endpoint behavior, check the link from the top of this post.

Create TokenProviderEndpointBehavior

We need to have another custom endpoint behavior for providing the token to access the Service Bus.

This is where the implementation differs from Paolo's example, as we do not use WindowsTokenProvider or OAuthTokenProvider for creating the token. Instead, we are using SharedAccessSignatureTokenProvider and you can find the code example for the endpoint behavior below (modified from Paolo's original example). Please note that code needs a reference to Microsoft.ServiveBus.dll, which is located at "C:\Program Files\Service Bus\(your Service Bus version number)\" by default.

using System;
 using System.Configuration;
 using System.Diagnostics;
 using System.ServiceModel.Channels;
 using System.ServiceModel.Configuration;
 using System.ServiceModel.Description;
 using System.ServiceModel.Dispatcher;
 using Microsoft.ServiceBus;
 
 public class TokenProviderBehaviorExtensionElement : BehaviorExtensionElement
 {
 #region Private Constants
 private const string KeyNamePropertyName = "sharedAccessKeyName";
 private const string KeyNamePropertyDescription = "Gets or sets the shared access key name.";
 private const string KeyPropertyName = "sharedAccessKey";
 private const string KeyPropertyDescription = "Gets or sets the shared access key.";
 private const string IsTrackingEnabledPropertyName = "isTrackingEnabled";
 private const string IsTrackingEnabledPropertyDescription = "Gets or sets a value indicating whether tracking is enabled.";
 #endregion
 
 #region BehaviorExtensionElement Members
 /// 
 /// Creates a behavior extension based on the current configuration settings.
 /// 

 /// The behavior extension.
 protected override object CreateBehavior()
 {
 return new TokenProviderEndpointBehavior(SharedAccessKeyName, SharedAccessKey, IsTrackingEnabled);
 }
 
 /// 
 /// Gets the type of behavior.
 /// 

 public override Type BehaviorType
 {
 get
 {
 return typeof(TokenProviderEndpointBehavior);
 }
 }
 #endregion
 
 #region Public Properties
 /// 
 /// Gets or sets the shared access key name.
 /// 

 [ConfigurationProperty(KeyNamePropertyName, IsRequired = true)]
 [SettingsDescription(KeyNamePropertyDescription)]
 public string SharedAccessKeyName
 {
 get
 {
 return (string)base[KeyNamePropertyName];
 }
 set
 {
 base[KeyNamePropertyName] = value;
 }
 }
 
 /// 
 /// Gets or sets the shared access key.
 /// 

 [ConfigurationProperty(KeyPropertyName, IsRequired = true)]
 [SettingsDescription(KeyPropertyDescription)]
 public string SharedAccessKey
 {
 get
 {
 return (string)base[KeyPropertyName];
 }
 set
 {
 base[KeyPropertyName] = value;
 }
 }
 
 /// 
 /// Gets or sets a value indicating whether tracking is enabled.
 /// 

 [ConfigurationProperty(IsTrackingEnabledPropertyName, DefaultValue = true, IsRequired = false)]
 [SettingsDescription(IsTrackingEnabledPropertyDescription)]
 public bool IsTrackingEnabled
 {
 get
 {
 return (bool)base[IsTrackingEnabledPropertyName];
 }
 set
 {
 base[IsTrackingEnabledPropertyName] = value;
 }
 }
 #endregion
 }
 
 public class TokenProviderEndpointBehavior : IEndpointBehavior
 {
 #region Private Constants
 private const string MessageFormat = "[TokenProviderEndpointBehavior] TokenProvider = {0}, key = {1}";
 #endregion
 
 #region Private Fields
 private readonly string sharedAccessKeyName;
 private readonly string sharedAccessKey;
 private readonly bool isTrackingEnabled;
 #endregion
 
 #region Public Constructors
 /// 
 /// Initializes a new instance of the TokenProviderEndpointBehavior class.
 /// 

 /// The shared access key name.
 /// The shared access key.
 /// A boolean value indicating whether tracking is enabled.
 public TokenProviderEndpointBehavior(string sharedAccessKeyName,
 string sharedAccessKey,
 bool isTrackingEnabled)
 {
 this.sharedAccessKeyName = sharedAccessKeyName;
 this.sharedAccessKey = sharedAccessKey;
 this.isTrackingEnabled = isTrackingEnabled;
 }
 #endregion
 
 #region IEndpointBehavior Members
 /// 
 /// Implement to pass data at runtime to bindings to support custom behavior.
 /// 

 /// The endpoint to modify.
 /// The objects that binding elements require to support the behavior.
 void IEndpointBehavior.AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
 {
 var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(sharedAccessKeyName, sharedAccessKey);
 bindingParameters.Add(new TransportClientEndpointBehavior
 {
 TokenProvider = tokenProvider
 });
 Trace.WriteLineIf(isTrackingEnabled, string.Format(MessageFormat, tokenProvider.GetType(), sharedAccessKeyName));
 }
 
 void IEndpointBehavior.ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
 {
 }
 
 void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
 {
 }
 
 void IEndpointBehavior.Validate(ServiceEndpoint endpoint)
 {
 }
 #endregion
 }

Create additional endpoint behaviors

Paolo also introduces SessionChannelEndpoint behavior for receiving messages from sessionful queue or subscription and ServiceBusMessageInspector for converting Service Bus message properties into BizTalk context properties. Consider whether they are useful for you, but they are not necessary in order to get the basic integration working.

Build and deploy endpoint behaviors

After you have created all custom endpoint behaviors, preferably to a separate class library project, you can go ahead, build the project, and deploy the DLL into GAC (for example by using the GACUTIL tool).

Also, make sure that the referenced Service Bus assembly (Microsoft.ServiceBus.dll) can be accessed from your assemblies at runtime. Simplest way to ensure that is by inserting it also into GAC.

Present endpoint behaviors to WCF-Custom adapter

Create a configuration file for WCF-Custom adapter:

Copy content from the example below and save it to a temporary location with .config -extension
Replace assembly type attribute contents with correct values of your assembly built in the previous step, only 'bizTalkListenUri' and 'bizTalkSecurity' rows
Verify that version number of Microsoft.ServiceBus assembly is correct in all other rows (Service Bus 1.1 works with the DLL version 2.1.0.0)

Import the configuration file:

Open 'BizTalk Administration Console'
Expand the navigation tree to 'BizTalk Administration' > 'BizTalk Group' > 'Platform Settings' > 'Adapters'
Select 'WCF-Custom' from the navigation tree
Double-click receive handler in the right-hand pane and click Properties-button
Click Import-button and select the configuration file from your hard drive

Create and configure the receive location

Create new Receive Location and specify following properties:

Select 'WCF-Custom' adapter
Select 'XMLReceive' pipeline
Click Configure-button

In the General-tab:

Specify the address of the topic, for example "sb://yourserver.domain.com/ServiceBusDefaultNameSpace/your_topic_name"

In the Binding-tab:

Select 'netMessagingBinding' as binding type

In he Behavior-tab:

Right-click 'EndpointBehavior' in left-hand pane and select 'Add extension'
Select 'bizTalkSecurity' from the list and click OK
Enter shared access key and key name in right-hand pane
Right-click 'EndpointBehavior' in left-hand pane and select 'Add extension'
Select 'bizTalkListenUri' from the list and click OK
Enter full URL to your subscription in right-hand pane, for example: "sb://yourserver.domain.com/ServiceBusDefaultNameSpace/your_topic_name/subscriptions/your_subscription_name"

That should do it and by starting the receive location, messages from the Service Bus should start appearing in BizTalk.

Queries failing because of the ARITHABORT setting

MikkoLe — Thu, 02 Jan 2014 23:24:00 GMT

So here is the scenario: you have a stored procedure which inserts new rows to a database table and you want to call it from your .NET code (in my case the application was a BizTalk orchestration using WCF-SQL adapters). You can successfully execute the procedure in SQL Server Management Studio, but when your code calls it, you get an error like this:

INSERT failed because the following SET options have incorrect settings: 'ARITHABORT'

The exception is pretty clear, you have ARITHABORT set to 'OFF' but you are trying to insert a row into a table that is referenced in an indexed view, or performing some other operation that requires the ARITHABORT setting to be 'ON'. Reason why the stored procedure works in SSMS is simply because it uses 'ON' as a default setting for ARITHABORT while OLE DB connection provider doesn't. You can find more information about the ARITHABORT setting from here: https://technet.microsoft.com/en-us/library/ms190306.aspx

You can also use the SQL Server Profiler to find out what statements get executed before your stored procedure is actually called. In WCF-SQL adapter's case the ARITHABORT is explicitly set to 'OFF':

-- network protocol: TCP/IP
 set quoted_identifier on
 set arithabort off
 set numeric_roundabort off
 set ansi_warnings on
 set ansi_padding on
 set ansi_nulls on
 set concat_null_yields_null on
 set cursor_close_on_commit off
 set implicit_transactions off
 set language us_english
 set dateformat mdy
 set datefirst 7
 set transaction isolation level serializable

Resolving the error is pretty easy, you add the following line after the BEGIN clause in your stored procedure:

SET ARITHABORT ON;

You can also modify the setting on the database level by right-clicking your database in SSMS and selecting Properties > Options. In the list under the Miscellaneous-section you find the 'Arithmetic Abort Enabled'-setting:

Access denied when deploying BizTalk solutions from Visual Studio

MikkoLe — Fri, 04 Oct 2013 01:37:00 GMT

There is a possibility to get various kind of access denied errors when deploying BizTalk solutions directly from Visual Studio. Here is my list of things to check if you are struggling to get past the errors.
By the way, if you are deploying your first BizTalk solution, you might also want to check the walkthrough of a basic deployment from MSDN (https://msdn.microsoft.com/en-us/library/aa559168(v=bts.80).aspx).

- Make sure you have administrator rights on the server and you run Visual Studio as administrator. This is required because BizTalk assemblies are deployed into GAC (https://msdn.microsoft.com/en-us/library/yf1d93sz.aspx).

- Make sure your user account is member of BizTalk Server Administrators group and also member of SSO Administrators or SSO Affiliate Administrators group. These memberships should grant you required access to the database.

- Verify that your deployment configuration is correct by right-clicking the project in Visual Studio and selecting "Properties". Check that values for "Application Name", "Configuration Database" and "Server" are what you expect them to be. Note that the value of the "Server" should be the name of the SQL Server instance that hosts the Configuration Database.

- Make sure you have AssemblyInfo.cs file included in your project and it contains this line:

[assembly: Microsoft.XLANGs.BaseTypes.BizTalkAssembly(typeof(Microsoft.BizTalk.XLANGs.BTXEngine.BTXService))]

- When everything else is checked, you might also want to check if some other process has a lock on the file(s) you are trying to replace. This can be done for example with Process Monitor (https://technet.microsoft.com/en-us/sysinternals/bb896653.aspx) by using "Find" -> "Find Handle or DLL" -> Enter path and filename of the DLL being updated. At least search indexing services or virus scanners might acquire these kind of locks which prevent you from replacing the file. Stopping these services while deploying should help.

Unit testing JavaScript in Visual Studio 2012

MikkoLe — Mon, 19 Aug 2013 00:00:00 GMT

As most of the user interface functionality is nowadays being written in JavaScript, it is very important to know how to unit test your JavaScript code. It's actually pretty easy to implement unit tests for JavaScript in Visual Studio 2012, and this article describes how it's done. However, please note that the testing frameworks and Visual Studio extensions presented in this article are not developed by Microsoft and supported only by individuals or teams who have built them.

Let's say you have created a new Web Application project, added a new JavaScript file called code.js and written a simple script that you want to test. Contents of that file look like this:

var myMathLib = {
 sum: function (a, b) {
 return a + b;
 }
}

Writing the tests

You need to start by selecting which framework you will use to test your scripts. Couple of good alternatives are QUnit and Jasmine (which is actually more of a behavior-driven development framework). These frameworks also have good extensions for Visual Studio which enable you to have great integrated development experience. Below you can find simple examples written for these frameworks, please note that they also support pretty advanced testing scenarios and you can find more info about the features from the links below.

QUnit (https://qunitjs.com/)

QUnit is one of the most popular testing frameworks and it's being used by jQuery and other popular JavaScript libraries. You can implement your test script to a separate file or folder, for example code-tests.js and the actual code for the test would look like this:

test("sum of 1 and 2", function () {
 var res = myMathLib.sum(1, 2);
 equal(res, 3, "is 3");
});

Jasmine (https://pivotal.github.io/jasmine/)

In Jasmine, tests are written in BDD (https://en.wikipedia.org/wiki/Behavior-driven_development) style. With Jasmine you also write tests to a separate file and the same test we wrote for QUnit would look like this:

describe("using myMathLib", function () {
 it("sum of 1 and 2 is 3", function () {
 expect(myMathLib.sum(1, 2)).toBe(3);
 });
});

Running the tests

Now that the tests are written, you need to figure out how to run them. As JavaScript is executed by the browser, JavaScript testing frameworks are usually using a harness html that you open in a browser to run the tests. For running tests in Visual Studio, there is a great extension called Chutzpah (https://chutzpah.codeplex.com/) which handles all the fuss for you in the background. What's great about Chutzpah is that it also has built in support for testing code written in TypeScript (https://www.typescriptlang.org/) which you definitely need to check out if you are a C# developer and you don't already know what TypeScript is!

With Chutzpah installed, you don't need to have the harness file at all. It uses PhantomJS (https://phantomjs.org/) headless browser to run the tests in the background. One thing that you need to notice though is that all test files need to have the reference to the actual script file that contains the code to be tested. This can be achieved by adding this line to the top of the test script file (replace path attribute with relative path to your code file):

///

Another benefit from using Chutzpah is that you don't need to reference test framework JavaScript libraries manually. Chutzpah has built in support for both QUnit and Jasmine test frameworks.

Actually Chutzpah is not just one extension, but has two extensions which you can choose from, or even install both if you want:

Context Menu Extension (https://visualstudiogallery.msdn.microsoft.com/71a4e9bd-f660-448f-bd92-f5a65d39b7f0)

This extension enables you to run tests directly from Visual Studio context menu. After the extensions is installed you are good to go, right-click JavaScript test file and you should see the new menu items:

Selecting "Run JS Tests" will give output of the tests run to Output-window:

As you noticed, you can also "Open in browser" to get more detailed report on the test run if the suppressed results of the Output window don't suit your needs.

Unit Test Explorer Test Adapter (https://visualstudiogallery.msdn.microsoft.com/f8741f04-bae4-4900-81c7-7c9bfb9ed1fe)

This extension adds support for plugging in to Visual Studio's built in Unit Test Explorer. After this extension is installed, JavaScript unit tests will show up in Unit Test Explorer same way as any unit tests written in C# would be shown:

Also it is good to note that if you happen to own a ReSharper license, you are good to go without installing Chutzpah extensions as it also has support for tests written in QUnit and Jasmine built-in. More info about JavaScript unit testing in ReSharper can be found here: https://www.jetbrains.com/resharper/webhelp/ReSharper_by_Language__JavaScript__Unit_Testing.html

Integrating unit tests with team builds

When working in projects with multiple developers, it's a good practice to run unit tests with team builds.

Chutzpah works great with Team Foundation Server and there is a good article in Visual Studio ALM blog which has detailed instructions how to run tests in your TFS builds: https://blogs.msdn.com/b/visualstudioalm/archive/2012/07/09/javascript-unit-tests-on-team-foundation-service-with-chutzpah.aspx

Chutzpah also includes a command line runner, so you can basically run the tests from any system (or custom build process) by calling the executable. Running the tests from command line is pretty straight-forward:

Chutzpah.console.exe (path-to-test-file) [options]

All options of command line runner can be found from here: https://chutzpah.codeplex.com/wikipage?title=Command%20Line%20Options&referringTitle=Documentation

Summary

So that's about it, with Visual Studio 2012 you can use the most popular JavaScript unit test frameworks and have a great development experience by using a Visual Studio extension. Hopefully with these tools you can increase quality of you JavaScript code and reduce time spent for debugging the code in the browser.

Evaluating BizTalk on Azure IaaS

MikkoLe — Sat, 20 Apr 2013 23:23:00 GMT

General availability of Infrastructure as a Service (IaaS) support for Windows Azure was released this week. This means that you are able to run production applications on Virtual Machines hosted in Azure, backed by an enterprise SLA and supported by Microsoft Support. More info about the release can be found from Scott Guthrie's blog: https://weblogs.asp.net/scottgu/archive/2013/04/16/windows-azure-general-availability-of-infrastructure-as-a-service-iaas.aspx

If you have BizTalk implementations currently running on-premise, you might want to evaluate how running them on Azure IaaS would help with your hosting challenges or cut operational costs. Starting up a single-server evaluation environment is super easy, and this is how it's done:

First, go to https://manage.windowsazure.com/ and sign in with your Microsoft Account that linked to your Azure subscription
- If you don't have a subscription you can sign up for a free trial at: https://www.windowsazure.com/en-us/pricing/free-trial/
- Also, if you are a MSDN subscriber, you get limited free access to Azure, read details about the benefits here: https://www.windowsazure.com/en-us/pricing/member-offers/msdn-benefits/

Click on "+ NEW" button located at the bottom left corner and select Compute -> Virtual Machine -> From Gallery

Step1 (of the creation process): Select the virtual machine image to be created, which in BizTalk's case means that you need to select the edition of the product
- Evaluation edition contains evaluation versions of both BizTalk 2013 and SQL Server 2012
- Standard and Enterprise editions contains BizTalk 2013 and are meant for scaled out (production) environments where SQL is installed in a separate virtual machine
- Important: Refer to Azure pricing page to learn the rates of different editions: https://www.windowsazure.com/en-us/pricing/details/virtual-machines/
- Also note that Visual Studio is not part of these images at this time

Step2: Enter virtual machine configuration
- Machine name for your virtual machine
- User name and password of the local user which will be created on the virtual machine automatically
- Select size of your machine
- Important: Refer to Azure pricing page to learn the rates of different sizes: https://www.windowsazure.com/en-us/pricing/details/virtual-machines/

Step3: Select virtual machine mode
- Enter DNS name of the virtual machine, this is the address which you will use to access the virtual machine
- Virtual machine needs an storage account which is used to store the virtual machine image (VHD files)
- If you don't have an existing storage account you want to use, you can have the creation process to generate one for you
- It's also good to note that using the storage will generate costs even if you shut down the virtual machine
- Select region where you want the virtual machine to run (selecting nearest datacenter minimizes possible network latencies)

Step4: Select additional options
- You can select an availability set to ensure availability of your application in case of hardware failures
- In most evaluation cases you can leave this to "(None)"
- More info about availability sets can be found from here: https://www.windowsazure.com/en-us/manage/windows/common-tasks/manage-vm-availability/

After completing the process, Azure starts provisioning of your virtual machine.
- You can see the status of the process by clicking the green bars in the right hand side of the bottom bar
- When the virtual machine is ready, you can start a Remote Desktop connection to the virtual machine by clicking the Connect icon in the bottom bar
- Use the credentials you provided in Step 2

You can also connect to your virtual machine without having to go through the Azure management portal.
- Remote Desktop endpoint is automatically created for you, you can find more info about endpoints here: https://www.windowsazure.com/en-us/manage/windows/how-to-guides/setup-endpoints/
- Go to the properties of your virtual machine and check the Remote Desktop port number from endpoint list
- Start a new remote desktop connection (Win + R -> mstsc)
- Enter the address you provided in Step 3 and public port defined in endpoint list
- Example: yourbiztalkserver.cloudapp.net:50144
- Use the credentials you provided in Step 2

When you have the Remote Desktop connection up and running..
- BizTalk tools are not pinned on taskbar or start menu, but you will find them in the Apps list (Win + Q)
- BizTalk is not configured by default, so you have to start by running the BizTalk Configuration tool
- Configuration is done by the same tool that you use on-premise, so you can refer to same documentation: https://msdn.microsoft.com/en-us/library/aa561189(v=bts.80).aspx
(UPDATE: MSDN has also Azure specific documentation about BizTalk configuration: https://msdn.microsoft.com/en-us/library/jj248689%28v=bts.80%29.aspx)
- When you have BizTalk configured you can start deploying your applications the same way you would do it on-premise (for example by importing MSI packages)

String equality comparison in C#

MikkoLe — Mon, 28 Jan 2013 04:52:00 GMT

Options for string equality comparison

Although the subject is pretty trivial, I thought I'd share my two cents on the topic because lately I've seen lots of different implementations, even within a single project. Some of them are:

foo == "bar"
You can't specify string comparison rules
(in my opinion, this does have the best readability)

foo.Equals("bar")
If foo is null, throws a NullReferenceException

String.Compare(foo, "bar") == 0
MSDN doesn't recommend this for checking equality

String.Equals(foo, "bar")
The most performant way, doesn't throw NullReferenceException and you can also specify comparison rules

StringComparison parameter

There is a recommendation on MSDN to use overloads that explicitly specify the string comparison rules, so you should always call the static method with a StringComparison parameter:

String.Equals(foo, "bar", StringComparison.OrdinalIgnoreCase)

Although string comparison logic rarely has a significant effect on the overall performance, you might consider using OrdinalIgnoreCase for case-insensitive comparison as it is faster than Ordinal (which is the default) and InvariantCultureIgnoreCase.

Extension method helper

You could also write an extension method to make your life a bit easier:

public static bool Eq(this string strA, string strB)
 {
   return String.Equals(strA, strB, StringComparison.OrdinalIgnoreCase);
 }

And call the extension method like this:

if (foo.Eq("bar"))
 {
 ...
 }