Many a time you might want to interact with Azure servicebus, but may not have the privilage to use the service bus dll. In such a scenario you would need to make use of Azure Servicebus REST API. A best example for this scenario would be connecting to Azure service bus from Windows Phone 7. As you may already know, you cannot make use of the service bus dll in a phone. In this post, I will walk you though every step required to complete the integration between Azure Service Bus Queue and your client REST API.

Step 1 : Set up your Azure Service Bus and Access Control Service (ACS)
Create a service bus namespace and an associate ACS namespace in your Azure account. Get the secret key from "Default Key" in your Azure service bus account. We will use this later to connect to Azure from your client application.

Step 2 : From client, get autentication token to Azure using REST
In this step we will get an authentication token from Azure and attach it in the header of all subsequent requests to interact with the service bus. To get an authentication token, you will need the issuer password (the secret key you got in last step), the issuer name (almost alway "owner") and your service namespace (the namespace for servicebus and ACS). The code listing for the same is given below. The ACS base address may change in future Azure releases. Rest of the code listing is self explanatory.

private void GetAuthenticationToken()
 {
 string acsBaseAddress = "https://" + ServiceNamespace + "-sb.accesscontrol.windows.net/WRAPv0.9/";
 
 // Create the body of the Post Request, formatted as a HTTP Form
 string postData = "wrap_scope=" + Uri.EscapeDataString("https://"+ ServiceNamespace +".servicebus.windows.net/") + "&wrap_name="
 + Uri.EscapeDataString(IssuerName) + "&wrap_password="
 + Uri.EscapeDataString(IssuerPassword);
 
 string authorizationToken;
 var webClient = new WebClient();
 webClient.UploadStringCompleted += new UploadStringCompletedEventHandler(webClient_GettingTokenCompleted);
 webClient.UploadStringAsync(new Uri(acsBaseAddress), "POST", postData);
 }

Step 3 : Extract the token and append it to the header of every subsequent requests
The result of the token request in step 2 arrives in a particular string format with '&' as the delimiter. To obtain the actual token, refer to the code snippet below.

private void webClient_GettingTokenCompleted(object sender, UploadStringCompletedEventArgs e)
 {
 string[] tokenVariables = e.Result.Split('&');
 string[] tokenVariable = tokenVariables[0].Split('=');
 string authenticationToken = Uri.UnescapeDataString(tokenVariable[1]);
 }

Step 4 :  Perform service bus operations using the authentiction token
Once you have the authentication token, append it to the header called "Authentication" to interact with the service bus. In the code snippet below, I will post a message to the service bus queue.

var webClient = new WebClient();
 webClient.Headers["Authorization"] = "WRAP access_token=\"" + authenticationToken + "\"";
 webClient.UploadStringCompleted += new UploadStringCompletedEventHandler(webClient_SendMessageCompleted);
 webClient.UploadStringAsync(
 new Uri(FullAddress), "POST", Body);

Similary you can perform any interacation with the service bus. You may also refer to MSDN REST API reference. Also do leave a comment with your questions/feedback and I would be happy to respond. Happy coding!

Microsoft Pex is a Visual Studio add-in that provides runtime code analysis for .NET code. With just a few mouse clicks, you can explore code-under-test to understand input/output behavior in the code, save automated tests that increase your confidence that your code cannot crash—or point to errors that do cause crashes and write powerful parameterized unit tests and generate suites of tests that ensure the code-under-test behaves as intended. If you are a developer writing code, you should be testing it with Pex. More tutorials here.

This post aims at providing a solution to two of the issues that I have come across.

Issue 1: The Pex context menu only has the entry "Delete Generated Unit Tests in Class" and not the usual "Create parameterized unit  tests"

Solution: The Pex assemblies should be referenced only in the test project and not in the source projects. For example in my case, the source project that contained the original class on which tests had to be run contained references to “Microsoft.Pex.Framework” & "Microsoft.VisualStudio.QualityTools.UnitTestFramework”. Once I removed the references, I had the “Create parameterized unit tests” menu back.

Issue 2: You already have an existing unit test project. But Pex is not allowing you to select the existing test project as output.

Solution: To your test project, add a reference to the assembly "Microsoft.Pex.Framework” and try again.

If that doesn’t work, follow the steps.
Update your existing test project:

- Run 'Create Parameterized Unit Tests' on your project
- Let Pex create a new project
- Copy the PexAssemblyInfo.cs file (under \Properties) from the generated  project into your original test project
- Delete the test project that Pex generated

At this point, the bindings should work. The next time you try to run 'Create Parmeterized Unit Tests' from your types, it should automatically suggest to use your test project.

Important Note on Pex download: Pex comes along with Moles which is a mocking framework. Starting Visual Studio 2012, moles has been integrated as "Fakes". They are not backward compactible. Hence if you would like to use a mocking framework, its is recommended that you have a look at "Fakes".

<endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>

 set the behaviors,

    <behaviors>

      <serviceBehaviors>

        <behavior name="mexBehavior">

          <serviceMetadata httpGetEnabled="true" />

        </behavior>

      </serviceBehaviors>

    </behaviors>

 and point your service to use the above behavior.

<service name="xxx.yyyService" behaviorConfiguration="mexBehavior">

If you have done all of the above and still have the problem, the culprit could be the svc file. Open the .svc file for your service by right clicking on the service > View markup. Check whether the Service tag of the svc file has the fully qualified name of the service including the namespace. Then make sure in the web.config, your service name and the endpoint contract also has the fully qualified name. If not, this should solve your issue.

https://appfabricadmin.codeplex.com/. Do provide your valuable feedback, bugs.

Project home page: https://appfabricadmin.codeplex.com/
Direct Download: https://appfabricadmin.codeplex.com/releases/81495/download/336376

Nothing technical today. Just came across an app for Windows Phone which brings Siri functionality to your Windows Phone. The best part is that the app is free! Download it for free from marketplace https://www.windowsphone.com/en-IN/apps/71970bb1-1de9-46a9-a602-040e1e7356cb". The response is a bit slow, but given that this is an initial build, we can look forward to better response time in near future. From the market place:

If you are craving Siri like functionality for Windows Phone and more, look no further. Ask Ziggy is your Personal Assistant that goes beyond Siri functionality. You can Call, Text, Email your contacts, Update Windows Live, Facebook, and Twitter, Get Weather, Stock Values, Flight Statuses, Get Ziggy to do Math, or ask any question you want (i.e. Who is the tallest person?) all by speaking to your phone.

Check out the sample videos at their home site.

Some systems, especially the financial ones require that the sequence of orders coming into the system be maintained after processing. This sounds like a simple problem to solve. But consider the same system in a scaled up scenario. There could be multiple receiver that picks up the order from an incoming queue and processes it in parallel pipes. How do we ensure that the after processing, the orders are sent out of the system in the same order? The problem we are trying to solve is what is known as resequencer problem.

Solution: Make each of the order coming into the system pass through a unique id generator. If each order has a unique sequence id, this step can be skipped. As soon as the unique id is generated, create an empty entry in an in-memory collection with the order id as key. The in-memory collection can be a SortedList or HashTable. Once the processing of each processing pipe is complete, the empty object in the in the in-memory queue is updated with the processed object. If the processed object is the first node in the in-memory queue, start sending the order to the external queue until an empty object is encountered.

Sample Flow:

1. Consider orders 1,2,3 in the incoming queue.
2. An in-memory sorted list is created with null values whose key is 1,2,3. Each order is processed by a different receiver and processing pipe.
3. Assume that for some reason that the pipe processing order 1 is slow. Hence orders 2,3 finished processing first and the processed object got updated in the empty queue.
4. The first node in the in-memory queue is still empty, but there are processed objects in the next nodes 2,3
5. As soon as order 1 is processed, the empty node is updated. Since this is the first node, the object is send to external queue and removed from in-memory queue. The pointer is incremented to find that there is object in node 2. This cycle is repeated until it encounters an empty node.

Questions:

1. What if the processing of one of the pipes slows down? Wouldn't it cause the other orders to wait before being sent to the external system?
Ans: Right! But remember, a system can only be as fast as its slowest link. This holds true in this case also.

2. Wouldn't the id generator and in-memory queue become a single point of failure?
Ans: To avoid this, you can maintain a copy of it in a cache. Server Appfabric cache with proper locks would help you achieve it.

Do share your thoughts and feedback on this solution; especially if you can think of a better solution. Happy coding! :)

1. The xxx service on Local Computer started and then stopped. Some services stop automatically if they are not in use by other services or programs.

or

2. Service cannot be started. System.ServiceModel.AddressAlreadyInUseException: HTTP could not register URL https://+:8011/PersistanceManager/ because TCP port 8011 is being used by another application. ---> System.Net.HttpListenerException: The process cannot access the file because it is being used by another process

Solution for problem 1: To find the root cause of the error, look into the event viewer. The most probable cause would the that the referenced assemblies or the app.config would not be present in the same directory as the executable. Also when you copy the app.config, make sure to rename it as applicationname.exe.config.

Solution for problem 2: Check if you have provided a port number for the mex address. Mex doesnt require a port number, so you can saferly remove it and the problem would be solved. If the problem still persists, check if any other application is using the same port number. You can make use of netsh command to accomplish this (search for how to use this command). If you are not running under administrative privilages, you can even allow everyone to make use of the port using the netsh command.

This should solve your problem in almost all cases. In case the problem still persists, do feel free to leave a comment and I will revert back. Happy coding! :)

For this simple example, lets consider that we need to process string messages which comes word "FIX:" or "SWIFT:". We will create mappers that can process these message types. Also do note that for that example I am placing all imports and exports in the same project. For true extensibility, do place the exports in external library files.

Make sure you have added references to System.ComponentModel dll and added the namespace System.ComponentModel.Composition & System.ComponentModel.Composition.Hosting. To begin with lets create the contracts which will be the avenue of communication between Imports and Exports. Contracts are nothing but the normal interface.

 public interface IMapper
 {
 String Map(String message);
 }
 
 public interface IMapperMetaData
 {
 String MessageType { get; }
 }

IMapper will be the extensible point for your application. The third party developers who will be extending your application should have reference to this. Apart from this, you can also add metadata information to your export so that you can load the appropriate components only at runtime. 

Next create the program that would compose all the parts (imports and exports are known as parts). I have added comments to the code as appropriate. The customMappers with ImportMany tag will contain all the exported parts which we will be creating later on.

 class MapperClass
 {
 [ImportMany(typeof(IMapper))]
 public IEnumerable<Lazy<IMapper,IMapperMetaData>> customMappers; //Lazy import ensures components are loaded only when required
 
 private CompositionContainer _container;
 
 public MapperClass()
 {
 var catalog = new AggregateCatalog();
 catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly)); //Locations to look for parts. If your export is in a an external dll, you need to use directory catalog as well 
 _container = new CompositionContainer(catalog);
 
 try
 {
 _container.ComposeParts(this); //Compose the imports and exports
 }
 catch (CompositionException ce)
 {
 Console.WriteLine(ce.Message);
 }
 }
 }

Its now time to create our exports. We will create two export parts which will be composed with the import we had defined earlier. You may place these two parts in seperate library, compile it and place it in the parent program executable location. Make sure you add a DirectoryCatalog with the directory to search for parts to the catalogs collection in the program above if you are using seperate DLLs.

 [Export(typeof(IMapper))]
 [ExportMetadata("MessageType", "FIX")]
 class FixMessage : IMapper
 {
 public string Map(string message)
 {
 return "Processed by FIX";
 }
 }
 

Finally its time to test out the program. Create a simple console app as follows:

 static void Main(string[] args)
 {
 MapperClass mc = new MapperClass();
 string s="FIX:2343";
 
 string []types=s.Split(':');
 bool processed = false;
 foreach(var i in mc.customMappers)
 {
 if (i.Metadata.MessageType == types[0])
 {
 processed = true;
 Console.WriteLine(i.Value.Map(s));
 }
 }
 if(!processed)
 Console.WriteLine("Could not process message as no matching mapper was found");
 Console.Read();
 }

The program would work perfectly well. Now change the value of 's' to "SWIFT:3234". The program would say that the mapper was not found. All you need to do is create another export and place it in the same directory.

 [Export(typeof(IMapper))]
 [ExportMetadata("MessageType", "SWIFT")]
 class SwiftMessage : IMapper
 {
 public string Map(string message)
 {
 return "Processed by SWIFT";
 }
 }

Hope I have succeeded in getting you to explore more on MEF, especially for those professionals who work extensively on building extensible applications. Do leave your valuable feedback and comments. Happy coding. :)

UPDATE:

To use directory catalog do the following:

catalog.Catalogs.Add(new DirectoryCatalog("."));

Compile FIX and SWIFT classes as seperate library dlls. You now need to place this in the same directory as the Mapper.exe. Do leave a comment if you have any questions.

• Read-Through/Write-Behind
• Graceful Shutdown
• Domain Accounts
• New ASP.NET Session State and Output Caching Provider
• Compression
• Multiple Cache Client Application Configuration Sections

Just yesterday I had written about the Read through - Write behind feature of 1.1 CTP. You can download the Windows Server Appfabric 1.1 RTM here. Read more about it at MSDN here.

• Read through - If a requested item doesn't exist in the cache, the data can be loaded from backend store and then inserted into cache. With a read-through provider, the cache detects the missing item and calls the provider to perform the data load. The item is then seamlessly returned to the cache client.  
• Write behind - In the same way, items that are added or updated in the cache can be periodically written to the backend store using a write-through provider. This happens asynchronously and on an interval defined by the cache.

One key scnarios where this feature is handy is when a client requests for an item that has already been removed from cache. The item will automatically be loaded back to cache from the backend store. Likewise the changes you do to the items in cache are persisted asynchronously from time to time without any user intervention.

To accomplish this feature, you will have to write a provider (class library) that extends DataCacheStoreProvider abstract class. Then you need to install (in gac) your provider to each of the cache host of the cache cluster. The final step is to configure your named cache to use this provider. To get started make sure you have installed the Windows Server Appfabric 1.1 CTP. Next, create  a C# class library and reference the library Microsoft.ApplicationServer.Caching. For 1.1 CTP, this is normally located under 'Program Files/Windows Server Appfabric'. Now implement the abstract class DataCacheStoreProvider.

using Microsoft.ApplicationServer.Caching;
 
 namespace SampleProvider
 {
 public class Provider:DataCacheStoreProvider
 {

 private String dataCacheName;
 private String connectionString;
 
 public Provider(string cacheName, Dictionary<string, string> config)
 {
 dataCacheName = cacheName; //Store the cache name for future use
 connectionString = config[0].Value;
 }
 
 public override void Delete(System.Collections.ObjectModel.Collection<DataCacheItemKey> keys){} 
 
 public override void Delete(DataCacheItemKey key){} 
 
 protected override void Dispose(bool disposing){} 
 
 public override void Read(System.Collections.ObjectModel.ReadOnlyCollection<DataCacheItemKey> keys, IDictionary<DataCacheItemKey, DataCacheItem> items){} 
 
 public override DataCacheItem Read(DataCacheItemKey key){} 
 
 public override void Write(IDictionary<DataCacheItemKey, DataCacheItem> items){} 
 
 public override void Write(DataCacheItem item){} 
 }
 }

A few things about the above code first. Your provider needs to have a constructor with the following signature. These parameters are passed in when your cache host initializes. The cacheName would contain the name of the cache for which you have created the provider. 

The config will contain any configuration details like the connection string that you can pass while registerting your provider in the final step. public Provider(String cacheName, Dictionary<string, string> config) The other methods you need to implement are the Read, Write, Delete and Dispose. 

You need not implement all the methods. If you want only read-through feature, just implement the Read. The following table gives you a gist of what each of the function does. 

Implementing Read

Read has two methods. One which takes a dictionary collection and the other takes a DataCacheItemKey. Read requests are always sent as a dictionary collection. Let us first implement the function with DataCacheItemkey parameter and then use it to process the other read function which accepts the dictionary collection.

 public override DataCacheItem Read(DataCacheItemKey key)
 {
 Object retrievedValue = null;
 DataCacheItem cacheItem;
 
 retrievedValue = ReadFromDatabase(key.Key); //Your implemented method that searches in the backend store based
 
 if (retrievedValue == null)
 cacheItem = null;
 else
 cacheItem = DataCacheItemFactory.GetCacheItem(key, dataCacheName, retrievedValue, null);
 return cacheItem; 
 }

You need to use DataCacheItemFactory class to create your cache item as follows DataCacheItemFactory.GetCacheItem(key, dataCacheName, retrievedValue, null). If the item is not found, we are returning null which matches with the cache cluster behaviour. Next lets implemet the read which accepts the dictonary collection.

 public override void Read(System.Collections.ObjectModel.ReadOnlyCollection<DataCacheItemKey> keys, IDictionary<DataCacheItemKey, DataCacheItem> items)
 {
 foreach (var key in keys)
 {
 items[key] = Read(key);
 }
 }

As mentioned before, we are just using the 'public override DataCacheItem Read(DataCacheItemKey key)' to read the items from backend store. You need to add the items to IDictionary<DataCacheItemKey, DataCacheItem> items as in the code above before returning from read method.

Implementing Write

Write is implemented the same way as read. It's important to remove the items which has been written to the backend store from the IDictionary<DataCacheItemKey, DataCacheItem> items. If you have successfully written all the values to the backend store, you can simply clear the items dictionary object by calling items.Clear().

 public override void Write(IDictionary<DataCacheItemKey, DataCacheItem> items)

Compiling your provider

Your provider should be signed with a stong key. To do this, go to your Project Properties> Signing > Check 'Sign the assembly'> Choose or create a strong key name file.

Installing your provider

Your provider should be placed in the GAC of all the hosts of the cluster. Run the visual studio command prompt and type in the following command to add your provider to gac.

gacutil /i SampleProvider.dll

You now need to get the fully qualified name of your provider. To do this type the command without the dll extension

gacutil /l SampleProvider

This would give you a message as follows:

SampleProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=0dca281230246e10, processorArchitecture=MSIL

We need to add the class details to the above message and remove the processorArchitecture. We will be using this string to register your provider with the cache 

SampleProvider.Provider, SampleProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=0dca281230246e10

Registering your provider

Time to fire up the cache administration powershell. Here I am registering a provider for an existing named cache. If you are creating a new cache, you need to use the same parameters with the new-cache command.

Set-CacheConfig TestCache -ReadThroughEnabled true -WriteBehindEnabled true -WriteBehindInterval 60 -ProviderType "SampleProvider.Provider, SampleProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=0dca281230246e10" -ProviderSettings @{"DbConnection"="<your connection string>";}

If your provider supports read through, set -ReadThroughEnabled to true. If your provider supports write behind, set -WriteBehindEnabled to true and also the interval between which cache items are persisted to database store. The minimum duration that can be set in this CTP is 60 seconds. In the -ProviderType, pass the string that we created in the step "Installing your provider". To pass config parameters to the initializer 'public Provider(string cacheName, Dictionary<string, string> config)', make use of -ProviderSettings as in example above. Make sure you have set the same config for all the hosts in your cluster. Once that is done, start your cache cluster. If any of your cache host fails to start, probably there is some problem with your provider. Look for errors in your system event log.

Testing your provider

To test your provider, create a sample test client and request for an item that is not present in cache. The read of your provider will be called when the cluster fails to find the item in cache. To test write, add an item to cache cluster and wait for the -WriteBehindTimeInterval to pass.

Debugging your provider

To debug your provider code, open the class project and then go to Debug>Attach to process> and select DistributedCacheService.exe. Put debug points as necessary. Read will be hit when you request for a key.

Feel free to send in your comments or questions. Happy coding. :)