In the last post about Service Bus Topics we discover how we can write code in such a way that migration from Service Bus Queues from Service Bus Topics can be done only changing the configuration file. Today I want to talk a little about what we should be aware where we process messages from topics using Peek and Lock pattern.
As we have already seen, Service Bus Topics allows us to process messages in two ways:
Receive and Delete – when messages are automatically removed after there are received
Peek and Lock – when messages are removed from the topic only after subscription call the Complete() method
We will talk about the last one. When we are using the Peel and Lock pattern, each message after is received from Service Bus is automatically locked and cannot be consumed by other client from the same subscription. If the client is able to process the message with success, he can call the Complete() method. In that moment the message is automatically removed from Service Bus. Is something happen with the message processing, for example an error occurred, the client can call the Abandon() message. In that moment the message is available once again for the given subscription. In the same time, after a message is send to a client of the given subscription, each client have a specific time when he can call Complete() or Abandon method(). If this method is not called, the message will be available one again for the given subscription. The default value is 60 seconds, but can be configured to any value.
In the next example we will try to process a message from the subscription. If an error occurred, in the catch block we will call the Abandon() method:
We should take care about two other things. The first one is what we are doing when we process a message. For example if we insert some information to database or call another service. In these cases we should have a transactional call. We should be able when calling the Abandon() message to rollback all things that we done.
To be able to make the rollback you can image very complicate scenarios ad there will be cases when an external service will not permit a rollback (for ex. if you call an external service). One simple solution involves the MessageId of each message. This id never changes, even if we call the abandon message for 100 times. Because of this we can store the MessageId in a list and check the id before processing it. In this way we will be able to know if we process the message already. We can image a situation when we have some steps for each message. We can store the step in this list. In this way we will not make some calls to different resources more than one. This type of processing is called “At least once processing”.
The other thing that we need to care about is about the messages that cannot be processed and will throw an error each time. For these cases, BrokeredMessage has a property that tells us how many times the client tried to processes the message. The name of the property is DeliveryCount. I gave a solution in another post for Service Bus Queues. The solution is the same for Service Bus Topics also. http://vunvulearadu.blogspot.hu/2012/08/service-bus-queues-from-windows-azure_1953.html
As we have already seen, Service Bus Topics allows us to process messages in two ways:
Receive and Delete – when messages are automatically removed after there are received
Peek and Lock – when messages are removed from the topic only after subscription call the Complete() method
We will talk about the last one. When we are using the Peel and Lock pattern, each message after is received from Service Bus is automatically locked and cannot be consumed by other client from the same subscription. If the client is able to process the message with success, he can call the Complete() method. In that moment the message is automatically removed from Service Bus. Is something happen with the message processing, for example an error occurred, the client can call the Abandon() message. In that moment the message is available once again for the given subscription. In the same time, after a message is send to a client of the given subscription, each client have a specific time when he can call Complete() or Abandon method(). If this method is not called, the message will be available one again for the given subscription. The default value is 60 seconds, but can be configured to any value.
In the next example we will try to process a message from the subscription. If an error occurred, in the catch block we will call the Abandon() method:
BrokeredMessage message = topicClient.Receive();
try
{
// process message
message.Complete();
} catch(Exception ex)
{
// log error
message.Abandon();
}
We would saw that the solution is okay and we covered this specials case. We have only on half of the solution. In a case of an error we abandon the message, this is great but what happens next? The message will be unlocked and we will be able to process it again.We should take care about two other things. The first one is what we are doing when we process a message. For example if we insert some information to database or call another service. In these cases we should have a transactional call. We should be able when calling the Abandon() message to rollback all things that we done.
To be able to make the rollback you can image very complicate scenarios ad there will be cases when an external service will not permit a rollback (for ex. if you call an external service). One simple solution involves the MessageId of each message. This id never changes, even if we call the abandon message for 100 times. Because of this we can store the MessageId in a list and check the id before processing it. In this way we will be able to know if we process the message already. We can image a situation when we have some steps for each message. We can store the step in this list. In this way we will not make some calls to different resources more than one. This type of processing is called “At least once processing”.
The other thing that we need to care about is about the messages that cannot be processed and will throw an error each time. For these cases, BrokeredMessage has a property that tells us how many times the client tried to processes the message. The name of the property is DeliveryCount. I gave a solution in another post for Service Bus Queues. The solution is the same for Service Bus Topics also. http://vunvulearadu.blogspot.hu/2012/08/service-bus-queues-from-windows-azure_1953.html
BrokeredMessage message = topicClient.Receive();
if(message == null)
{
Thread.Sleep(1000);
continue;
}
try
{
// process our message.
message.Complete()
}
catch(Exception ex)
{
if( message.DeliveryCount > 3 )
{
message.DeadLetter();
}
message.Abandon();
}
In this post we saw what we should handle some specials case situations when working we are receiving and processing message from Service Bus Topics. We should not ignore these cases because we can create duplicate data in our storage system or to process the same messages over and over again.
Comments
Post a Comment