In this post I'd like to talk about an architecture scenario we had recently and how we were able to utilise NServiceBus to help us address this problem.

Scenario

Cognos is a reporting system used by one of my clients. A while back we developed a web service façade to allow line of business applications to be able to access reports from Cognos to support their various functions.

The service was intended to provide access to reports which were quick running reports or pre-generated reports which could be accessed real-time on demand. One of the key aims of the web service was to provide a simple generic interface to allow applications to get any report without needing to worry about the complex .net SDK for Cognos.

The web service also supported multi-hop kerberos delegation so that report data could be accesses under the context of the end user.

This service was working well for a period of time.

The Problem

The problem we encountered was that reports were now also required to be available to batch processes. The original design was optimised for low latency so users would enjoy a positive experience, however when the batch processes started to request 250+ concurrent reports over an extended period of time you can begin to imagine the sorts of problems that come into play. The key problems this new scenario caused are:

1. Users may be affected and the latency of on demand reports was significantly slower
2. The Cognos infrastructure was not scaled sufficiently to be able to cope with these long peaks of load

From a cost perspective it just isn't feasible to scale the Cognos infrastructure to be able to handle the load when it is only for a couple of hour window each night. We really needed to introduce a second pattern for accessing this service which would support high through-put scenarios.

We also had little control over the batch process in terms of being able to throttle its load. We could however make some changes to the way it accessed the reports.

The Approach

My idea was to introduce a throttling mechanism between the Web Service Façade and Cognos. This would allow the batch processes to push reports requests hard at the web service which we were confident the web service can handle. The web service would then queue these requests and process them behind the scenes and make a call back to the batch application to provide the report once it had been accessed.

In terms of technology we had some limitations because we were not able to use WCF or IIS7 where the MSMQ-Activated WCF services could have helped, but we did have MSMQ as an option and I thought NServiceBus could do just the job to help us here.

The flow of how this would work was as follows:

1. The batch applications would send a request for a report to the web service
2. The web service uses NServiceBus to send the message to a Queue
3. The NServiceBus Generic Host is running as a windows service with a message handler which subscribes to these messages
4. The message handler gets the message, accesses the report from Cognos
5. The message handler calls back to the original batch application, this is decoupled because the calling application provides a call back url
6. The report gets into the batch application and is processed as normal

This approach looks something like the below diagram:

The key points are an application wanting to take advantage of the batch driven reports needs to do the following:

• Implement our call back contract
• Make a call to the service providing a call back url

• Provide a correlation ID so it knows how to tie each response back to its request

What does NServiceBus offer in this solution

So this scenario is not the typical messaging service bus type of solution people implement with NServiceBus, but it did offer the following:

• Simplified interaction with MSMQ
• Offered the ability to configure the number of processes working through the queue so we could find a balance between load on Cognos versus the applications end to end processing time
• NServiceBus offers retries and a way to manage failed messages
• NServiceBus offers a high availability setup

The simple thing is that NServiceBus gave us the platform to build the solution on. We just implemented a message handler which functionally processed a message and we could rely on NServiceBus to do all of the hard work around managing the queues and all of the lower level things that would have took ages to write to any kind of robust level.

Conclusion

With this approach we were able to deal with a fairly significant performance issue with out too much rework. Hopefully this write up gives people some insight into ideas on how to leverage the excellent NServiceBus framework to help solve integration and high through-put scenarios.