Azure Service Bus

Common Service Bus Queue Operations with the REST API

Rick G. Garibay — Thu, 19 Jan 2012 16:23:08 GMT

Azure Service Bus Brokered Messaging provides durable pull-based pub-sub, complimenting it’s older sibling Relay Messaging which uses a push messaging model. While both enable hybrid composition across traditional business, trust and network boundaries, they provide unique capabilities in and of themselves.

As with Relay Messaging, Brokered Messaging provides first class support for WCF with the NetMessagingBinding, but expands the developer surface to general .NET and cross-platform/mobility scenarios by offering the .NET Client and REST API respectively.

Of the 3 APIs, the .NET Client API is the most robust and seems to be the most documented.

The simplicity of the WCF programming model (the illusion that messages are being pushed to your endpoint) is balanced with some restrictions that naturally fall out of the scope of one-way messaging including queue/topic/subscription/rule creation and support for peek lock.

In this regard, while not as robust as the .NET Client API, the REST API offers a more comprehensive feature set and when working on solutions that must be interoperable across client platforms or due to other restrictions, the REST API is a great choice.

Microsoft has documented the REST API in the Service Bus REST API Reference, but there are not a ton of imperative examples out there that show WebClient or HttpWebRequest, so the purpose of this post is to share some nitty gritty examples of how to get some of the most common operations done in C#.

Please note that my goal is not to be elegant or use the tersest or most fluid syntax possible in this samples, but rather to get some quick and dirty examples out there, well, quickly.

As such, the unit tests should be self explanatory, but if you have any questions, please don’t hesitate to ask.

Feedback, comments related to the API or WebClient techniques welcome

   1:  using System;

   2:  using System.Text;

   3:  using System.Collections.Generic;

   4:  using System.Linq;

   5:  using Microsoft.VisualStudio.TestTools.UnitTesting;

   6:  using System.Collections.Specialized;

   7:  using System.Net;

   8:  using System.Runtime.Serialization.Json;

   9:  using System.Runtime.Serialization;

  10:  using System.IO;

11:

  12:  namespace RESTAPITests

  13:  {

  14:      [TestClass]

  15:      public class RESTAPITests

  16:      {

17:

  18:          static string serviceNamespace = "[NAMESPACE]";

  19:          static string issuerName = "owner";

  20:          static string issuerSecret = "[KEY]";

  21:          const string sbHostName = "servicebus.windows.net";

  22:          const string acsHostName = "accesscontrol.windows.net";

  23:          static string relativeAddress = "[Queue]";

  24:          static string baseAddress;

25:

26:

  27:          [TestMethod]

  28:          public void SendMessageShouldSucceedWithoutError()

  29:          {

  30:              string body = "foo";

31:

  32:              var token = GetToken(issuerName, issuerSecret);

33:

  34:              baseAddress = GetBaseAddress();

  35:              string fullAddress = baseAddress + relativeAddress + "/messages";

36:

  37:              WebClient webClient = new WebClient();

  38:              webClient.Headers[HttpRequestHeader.Authorization] = token;

  39:              webClient.UploadData(fullAddress, "POST", Encoding.UTF8.GetBytes(body));

40:

  41:          }

42:

  43:          [TestMethod]

  44:          public void PeekLockMessageShouldReturnLockId()

  45:          {

  46:              var token = GetToken(issuerName, issuerSecret);

47:

  48:              baseAddress = GetBaseAddress();

49:

  50:              // Read and lock the message. Unless released, the lock will expire within the configured lock duration (on the queue)

  51:              string fullAddress = baseAddress + relativeAddress + "/messages/head";

52:

  53:              WebClient webClient = new WebClient();

  54:              webClient.Headers[HttpRequestHeader.Authorization] = token;

  55:              webClient.UploadData(fullAddress, "POST", new byte[0]{});

56:

  57:              var props = webClient.ResponseHeaders["BrokerProperties"];

58:

  59:              // Deserialize the JSON header to a simple class

  60:              DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(BrokerProperty));

  61:              using (MemoryStream stream = new MemoryStream(Encoding.Unicode.GetBytes(props)))

  62:              {

  63:                  var result = (BrokerProperty)serializer.ReadObject(stream);

64:

  65:                  Assert.IsNotNull(result.LockToken);

  66:              }

67:

  68:          }

69:

  70:          [TestMethod]

  71:          public void PeekLockMessageAndAbandonShouldSucceed()

  72:          {

  73:              var token = GetToken(issuerName, issuerSecret);

74:

  75:              baseAddress = GetBaseAddress();

76:

  77:              // Read and lock the message. Unless released, the lock will expire within the configured lock duration (on the queue)

  78:              string fullAddress = baseAddress + relativeAddress + "/messages/head";

79:

  80:              WebClient webClient = new WebClient();

  81:              webClient.Headers[HttpRequestHeader.Authorization] = token;

  82:              webClient.UploadData(fullAddress, "POST", new byte[0] { });

83:

  84:              var props = webClient.ResponseHeaders["BrokerProperties"];

85:

  86:              // Deserialize the JSON header to a simple class

  87:              DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(BrokerProperty));

88:

  89:              using (MemoryStream stream = new MemoryStream(Encoding.Unicode.GetBytes(props)))

  90:              {

  91:                  var result = (BrokerProperty)serializer.ReadObject(stream);

92:

  93:                  // Bail on the message, release the lock so it is available for another consumer

  94:                  fullAddress = baseAddress + relativeAddress + String.Format("/messages/{0}/{1}", result.MessageId, result.LockToken);

  95:              }

96:

  97:              webClient = new WebClient();

  98:              webClient.Headers[HttpRequestHeader.Authorization] = token;

  99:              webClient.UploadData(fullAddress, "PUT", new byte[0] { });

 100:

 101:          }

 102:

 103:          [TestMethod]

 104:          public void PeekLockMessageAndCompleteShouldSucceed()

 105:          {

 106:              var token = GetToken(issuerName, issuerSecret);

 107:

 108:              baseAddress = GetBaseAddress();

 109:

 110:              // Peek lock the message

 111:              string fullAddress = baseAddress + relativeAddress + "/messages/head";

 112:

 113:              WebClient webClient = new WebClient();

 114:              webClient.Headers[HttpRequestHeader.Authorization] = token;

 115:              webClient.UploadData(fullAddress, "POST", new byte[0] { });

 116:

 117:              var props = webClient.ResponseHeaders["BrokerProperties"];

 118:

 119:              DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(BrokerProperty));

 120:

 121:              using (MemoryStream stream = new MemoryStream(Encoding.Unicode.GetBytes(props)))

 122:              {

 123:                  var result = (BrokerProperty)serializer.ReadObject(stream);

 124:

 125:                  // Complete the read operation, releasing the lock and deleting the message from the queue

 126:                  fullAddress = baseAddress + relativeAddress + String.Format("/messages/{0}/{1}", result.MessageId, result.LockToken);

 127:              }

 128:              webClient = new WebClient();

 129:              webClient.Headers[HttpRequestHeader.Authorization] = token;

 130:              webClient.UploadData(fullAddress, "DELETE", new byte[0] { });

 131:          }

 132:

 133:          [TestMethod]

 134:          public void DecodeJsonToTypeShouldAllowEasyExtractionOfProps()

 135:          {

 136:

137: string payload = @"{""DeliveryCount"":3,""LockToken"":""4a1d4c96-9837-42a9-ad91-3ecf704eec40"",""LockedUntilUtc"":""Thu, 19 Jan 2012 01:22:44 GMT"",

""MessageId"":""4a4fa2c7d87a40a7b799625b9de69e42"",""SequenceNumber"":2,""TimeToLive"":922337203685}";

 138:

 139:              DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(BrokerProperty));

 140:

 141:              using (MemoryStream stream = new MemoryStream(Encoding.Unicode.GetBytes(payload)))

 142:              {

 143:                  var result = (BrokerProperty)serializer.ReadObject(stream);

 144:

 145:                  Assert.IsNotNull(result.MessageId);

 146:              }

 147:

 148:          }

 149:

 150:          [DataContract]

 151:          public class BrokerProperty

 152:          {

 153:              [DataMember]

 154:              public string DeliveryCount { get; set; }

 155:              [DataMember]

 156:              public string LockToken { get; set; }

 157:              [DataMember]

 158:              public string LockedUntilUtc { get; set; }

 159:              [DataMember]

 160:              public string MessageId { get; set; }

 161:              [DataMember]

 162:              public string SequenceNumber { get; set; }

 163:              [DataMember]

 164:              public string TimeToLive { get; set; }

 165:          }

 166:

 167:

 168:          // Helper

 169:          private static string GetBaseAddress()

 170:          {

 171:              return baseAddress = "https://" + serviceNamespace + "." + sbHostName + "/";

 172:          }

 173:

 174:          // Helper, warmly borrowed from Service Bus Management Sample :-)

 175:          private static string GetToken(string issuerName, string issuerSecret)

 176:          {

 177:              var acsEndpoint = "https://" + serviceNamespace + "-sb." + acsHostName + "/WRAPv0.9/";

 178:

 179:              // Note that the realm used when requesting a token uses the HTTP scheme, even though

 180:              // calls to the service are always issued over HTTPS

 181:              var realm = "http://" + serviceNamespace + "." + sbHostName + "/";

 182:

 183:              NameValueCollection values = new NameValueCollection();

 184:              values.Add("wrap_name", issuerName);

 185:              values.Add("wrap_password", issuerSecret);

 186:              values.Add("wrap_scope", realm);

 187:

 188:              WebClient webClient = new WebClient();

 189:              byte[] response = webClient.UploadValues(acsEndpoint, values);

 190:

 191:              string responseString = Encoding.UTF8.GetString(response);

 192:

 193:              var responseProperties = responseString.Split('&');

 194:              var tokenProperty = responseProperties[0].Split('=');

 195:              var token = Uri.UnescapeDataString(tokenProperty[1]);

 196:

 197:              return "WRAP access_token=\"" + token + "\"";

 198:          }

 199:

 200:      }

 201:

 202:  }

NuCon 2012–Feb 16th, Irvine, CA

Rick G. Garibay — Mon, 16 Jan 2012 19:44:34 GMT

I’d like to pass on some details regarding an event I will be speaking on in Irvine, CA on February 16th.

NuCon is a one day conference put on by my employer, Neudesic that features talks and content from fellow Neudesic colleagues like David Pallmann, Ted Neward and Simon Guest, just to name a few.

As Irvine is Neudesic’s headquarters, the event provides a great opportunity to gain insight into the future of technology as seen by my fellow colleagues as well as providing pragmatic guidance that you can put to use the following day while networking with other Neudesic customers, executive management, partners and thought leaders to help guide your strategy on making the most of the tremendous opportunities that the Microsoft platform and Neudesic products have to offer.

In my talk, Hybrid Composition on the Microsoft Application Integration platform, I’ll share how organizations of all shapes and sizes can benefit from the improvement, automation and streamlining of their business operations through hybrid composition.

Abstract

In today’s technology landscape, exposing key functional areas as traditional services or other means has become the norm for achieving agility and is a requirement for taking advantage of the dramatic improvements that modern middleware capabilities both on-premise and in the cloud provide.

As organizations adapt to this new hybrid model, a shift from a homogenous, single product, big iron approach to heterogeneous, best in class, capability-driven model is necessary for realizing the benefits of service-orientation and enabling the composition of these services on-premise, in the cloud and behind the firewall without making big spending commitments on a product that may only meet some of these needs.

The Microsoft platform offers a number of capabilities for achieving these goals across common Hosting, Workflow, Rules, EAI and Messaging workloads that allow you to choose the right capabilities for delivering your intended business outcomes.

BizTalk Server 2010 and Windows Server AppFabric 1.1 provide a comprehensive middleware platform for developing, deploying, and managing composite enterprise capabilities on-premise and Windows Azure Service Bus and Access Control Service allow you to extend your investments beyond traditional trust and network boundaries making the cloud and other partner/vendor endpoints merely an extension of your enterprise.

Come learn how Windows Server AppFabric, WCF, WF Services, BizTalk Server and Windows Azure can benefit your approach to building and supporting application services at enterprise scale while transcending traditional trust boundaries and enabling the hybrid enterprise.

To give you an idea of the breadth and depth of the sessions, in my talk, I’ll be talking about and showing live demos of the latest capabilities that enable you to build hybrid composite solutions to drive differentiation and innovation within your organization:

Windows Server AppFabric 1.1 Caching (On-Prem) Featuring:

AppFabric distributed caching including implementing the Cache-Aside caching pattern and Read-Through caching, new in AppFabric 1.1

WF 4 Workflow Services (On-Prem) Featuring:

State Machine Activity, new in .NET 4.1 and .NET 4.5
AppFabric Connect BizTalk Mapper for WF 4 in AppFabric Connect
Long-running workflows
Workflow Correlation
Composition with WCF services in Windows Azure

Windows Server AppFabric Deployment (On-Prem) Featuring:

Easy deployment with Microsoft Web Deploy
Windows Server AppFabric Configuration Experience

WCF hosting in Windows Azure Web Roles (Cloud) Featuring:

Azure Web Role hosting
Azure Service Bus Topic client

Azure Service Bus Brokered Messaging (Hybrid) Featuring:

Brokered messaging from Azure to on-premise custom applications behind the firewall
Topics and Subscriptions

BizTalk Server 2010 Orchestration & Messaging (On-Prem) Featuring:

Custom WCF Adapter for consuming messages off an Azure Service Bus Topic
Support for custom WCF behaviors
Support for hybrid ERP integration such as Dynamics CRM or SAP

So, if you are interested in attending, please consider yourself invited! Click on the links in the invitation below to register (save $100 if you register before Feb 1) and I look forward to seeing you at NuCon 12!

Azure Service Bus Connect EAI and EDI “Integration Services” CTP

Rick G. Garibay — Fri, 16 Dec 2011 18:46:51 GMT

I am thrilled to share in the announcement that the first public CTP of Azure Service Bus Integration Services is now LIVE at http://portal.appfabriclabs.com.

The focus of this release is to enable you to build hybrid composite solutions that span on-premise investments such as Microsoft SQL Server, Oracle Database, SAP, Siebel eBusiness Applications, Oracle E-Business Suite, allowing you to compose these mission critical systems with applications, assets and workloads that you have deployed to Windows Azure, enabling first-class hybrid integration across traditional network and trust boundaries.

In a web to web world, many of the frictions addressed in these capabilities still exist, albeit to a smaller degree. The reality is that as the web and cloud computing continue to gain momentum, investments on-premise are, and will continue to be critical to realizing the full spectrum of benefits that cloud computing provides both in the short and long term.

So, what’s in this CTP?

Azure Service Bus Connect provides a new server explorer experience for LOB integration exposing a management head that can be accessed on-prem via Server Explorer or PowerShell to create, update, delete or retrieve information from LOB targets. This provides a robust extension of the Azure Service Bus relay endpoint concept, which acts a LOB conduit (LobTarget, LobRelay) for bridging these assets by extending the WCF LOB Adapters that ship with BizTalk Server 2010. The beauty of this approach is that you can leverage the LOB Adapters using BizTalk as a host, or, for a lighter weight way approach, use IIS/Windows Server AppFabric to compose business operations on-premise and beyond.

In addition, support for messaging between trading partners across traditional trust boundaries in business-to-business (B2B) scenarios using is EDI is also provided in this preview, including AS2 protocol support with X12 chaining for send and receive pipelines, FTP as transport for X12, agreement templates, partners view with profiles per partner, resources view, and an intuitive, metro style EDI Portal.

Just as with on-premise integration, friction always exists when integrating different assets which may exist on different platforms, implement different standards and at a minimum have different representations of common entities that are part of your composite solution’s domain. What is needed is a mediation broker that can be leveraged at internet-scale, and apply message and protocol transformations across disparate parties and this is exactly what the Transforms capability provides. Taking an approach that will be immediately familiar to the BizTalk developer, a familiar mapper-like experience is provided within Visual Studio for interactively mapping message elements and applying additional processing logic via operations (functoids).

In addition, XML Bridges which include the XML One-Way Bridge and XML Request-Reply Bridge are an extension to the Azure Service Bus which supports critical patterns such as protocol bridging, routing actions, external data lookup for message enrichment and support for both WS-I and REST endpoints and any combination thereof.

As shown below in the MSDN documentation, “bridges are composed of stages and activities where each stage is a message processing unit in itself. Each stage of a bridge is atomic, which means either a message completes a stage or not. A stage can be turned on or off, indicating whether to process a message or simply let it pass through”.

Taking a familiar VETR approach to validate, extract, transform and route messages from one party to another, along with the ability to enrich messages by composing other endpoint in-flight (supported protocols include HTTP, WS-HTTP and Basic HTTP, HTTP Relay Endpoint, Service Bus Queues/Topics and any other XML bridge) the Bridge is a very important capability and brings very robust capabilities for extending Azure Service Bus as a key messaging broker across integration disciplines.

In reality, these patterns have no more to do with EAI than with traditional, contemporary service composition and become necessary once you move from a point-to-point approach and need to elegantly manage integration and composition across assets. As such, this capability acts as a bridge to Azure Service Bus that is very powerful in and of itself, even in non-EAI/EDI scenarios where endpoints can be virtualized increasing decoupling between parties (clients/services). In addition, this capability further enriches what is possible when using the BrokeredMessage property construct as a potential poor-man’s routing mechanism.

In closing, the need to address the impedance mismatch that exists between disparate applications that must communicate with each other is a friction that will continue to exist for many years to come, and while traditionally, many of these problems have been solved by expensive, big iron middleware servers, this is changing.

As with most technologies, often new possibilities are unlocked that are residual side-effects of something bigger, and this is certainly the case with how both innovative and strategic Azure Service Bus is to Microsoft’s PaaS strategy. Azure Service Bus continues to serve as a great example of a welcomed shift to a lightweight capability-based, platform-oriented approach to solving tough distributed messaging/integration problems while honoring the existing investments that organizations have made and benefiting from a common platform approach which is extremely unique in the market. And while this shift will take some time, in the long-run enterprises of all shapes and sizes only stand to benefit.

To get started, download the SDK & samples from http://go.microsoft.com/fwlink/?LinkID=184288 and the tutorial & documentation from http://go.microsoft.com/fwlink/?LinkID=235197 and watch this and the Windows Azure blog for more details coming soon.

Happy Messaging!

DCC 2011.2 Lap Around Azure Service Bus: The Goods

Rick G. Garibay — Sat, 05 Nov 2011 21:33:25 GMT

Thanks to all that came out to my “Lap Around Azure Service Bus Brokered Messaging” talk at Desert Code Camp today.

We covered a ton of content including things a few folks didn’t know about relay messaging capabilities in Azure Service Bus and demonstrated how simple it is to expose a REST or SOAP endpoint from behind the firewall. I also demonstrated the brand new load balancing capabilities that were just released last week.

From there, we dove deep into the .NET API to walk through how to provision queues and topics from code and start messaging within minutes by simply grabbing the Azure Service Bus NuGet package and writing a few lines of code.

Next, we explored the REST API, and how simple it is for any HTTP client, regardless of platform to take advantage of the robust messaging capabilities that Azure Service Bus queues and topics have to offer.

Last but not least, we wrapped up with a quick walkthrough of the NeMessagingBinding and how simple it is to send and receive messages over a queue using the familiar WCF programming model.

I hope that each of you will unlock new possibilities with the power that these hybrid messaging capabilities have to offer.

I’d also like to thank Pluralsight for sponsoring my session. The quiz is now up for the first 5 smartest attendees.

Search for hashtags #dcc11 #Azure #ServiceBus #Q1 to #Q5.

Good Luck!

Code Demos

Happy Messaging!

Azure AppFabric Service Bus Brokered Messaging GA & Rude CTP Diffs

Rick G. Garibay — Wed, 14 Sep 2011 16:46:52 GMT

Today at the Build conference in Anaheim California, Satya Nadella, President Server and Tools business announced general availability of the production release of AppFabric Queues and Topics, otherwise known as Brokered Messaging.

Brokered Messaging introduces durable queue capabilities and rich, durable pub-sub with topics and subscriptions that compliment the existing Relayed Messaging capabilities.

I covered Brokered Messaging following the May CTP release of Queues and followed up shortly with an overview and exploration of Topics (please see some other great resources at the end of this post).

Since then, there was a June CTP release which included the new AppFabric Application and no visible changes to Brokered Messaging, however since its release, the AppFabric Messaging team has been hard at work refining the API and behaviors based on feedback from Advisors, MVPs and the community at large.

Since I’ve already covered Queues and Topics in the aforementioned posts, I’ll dive right in to some terse examples which demonstrate the API changes. Though not an exhaustive review of all of the changes, I’ve covered the types that your most likely to come across and will cover Queues, Topics and Subscriptions extensively in my upcoming article in CODE Magazine which will also include more in-depth walk-throughs of the .NET Client API, REST API and WCF scenarios.

Those of you who have worked with the CTPs will find some subtle and not so subtle changes, but all in all I think all of the refinements are for the best and I think you’ll appreciate them as I have. For those new to Azure AppFabric Service Bus Brokered Messaging, you’ll benefit most from reading my first two posts based on the May CTP (or any of the resources at the end of this post) to get an idea of the why behind queues and topics and then come back here to explore the what and how.

A Quick Note on Versioning

In the CTPs that preceded the release of the new Azure AppFabric Service Bus features, a temporary assembly called “Microsoft.ServiceBus.Messaging.dll” was added to serve a container for new features and deltas that were introduced during the development cycle. The final release includes a single assembly called “Microsoft.ServiceBus.dll” which contains all of the existing relay capabilities that you’re already familiar with as well as the addition of support for queues and topics. If you are upgrading from the CTPs, you’ll want to get ahold of the new Microsoft.ServiceBus.dll version 1.5 which includes everything plus the new queue and topic features.

The new 1.5 version of the Microsoft.ServiceBus.dll assembly targets the .NET 4.0 framework. Customers using .NET 3.5 can continue using the existing Microsoft.ServiceBus.dll assembly (version 1.0.1123.2) for leveraging the relay capabilities, but must upgrade to .NET 4.0 to take advantage of the latest features presented here.

.NET Client API

Queues

May/June CTP	General Availability	Comments
ServiceBusNamespaceClientSettings	NamespaceManagerSettings	New class for encapsulating endpoint and security settings.
N/A	TokenProvider	New class for acquiring a WRAP token from ACS.
ServiceBusNamespaceClient	NamespaceManager	Root management object for creating Queues, Topics, Subscriptions.
Queue	QueueDescription	In May/June CTP, Topic / Queue / Subscription were management objects. All create/delete operations were moved to NamespaceManager and the state operations are now on TopicDescription/QueueDescription etc.
MessagingFactorySettings	MessagingFactorySettings	New class for encapsulating security settings.
MessagingFactory	MessagingFactory
BrokeredMessage	BrokeredMessage	No longer a factory. Simply instantiate a BrokeredMessage.
MessageSender	MessageSender	Optional, for use when you want to abstract away queue or topic.
MessageReceiver	MessageReceiver	Optional, for use when you want to abstract away queue or topic.

Below is a representative sample for creating, configuring, sending and receiving a message on a queue:

Administrative Operations

  1: 
  2:             // Configure and create NamespaceManager for performing administrative operations
  3:             NamespaceManagerSettings settings = new NamespaceManagerSettings();
  4:             TokenProvider tokenProvider = settings.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuer,key);
  5:             
  6:             NamespaceManager manager = new NamespaceManager(ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty), settings);
  7: 
  8:             // Check for existence of queues on the fabric
  9:             var qs = manager.GetQueues();
 10: 
 11:             var result = from q in qs
 12:                          where q.Path.Equals(queueName, StringComparison.OrdinalIgnoreCase)
 13:                          select q;
 14: 
 15:             if (result.Count() == 0)
 16:             {
 17:                 Console.WriteLine("Queue does not exist");
 18: 
 19:                 // Create Queue
 20:                 Console.WriteLine("Creating Queue...");
 21: 
 22:                 manager.CreateQueue(new QueueDescription(queueName) { LockDuration = TimeSpan.FromSeconds(5.0d) });
 23:                 
 24:             }

Runtime Operations

  1:             // Create and Configure Messaging Factory to provision QueueClient
  2:             MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings();
  3:             messagingFactorySettings.TokenProvider = settings.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuer, key);
  4:             MessagingFactory messagingFactory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty), messagingFactorySettings);
  5:             
  6:             QueueClient queueClient = messagingFactory.CreateQueueClient(queueName, ReceiveMode.PeekLock);
  7: 
  8:             Order order = new Order();
  9:             order.OrderId = 42;
 10:             order.Products.Add("Kinect", 70.50M);
 11:             order.Products.Add("XBOX 360", 199.99M);
 12:             order.Total = order.Products["Kinect"] + order.Products["XBOX 360"];
 13: 
 14:             // Create a Brokered Message from the Order object
 15:             BrokeredMessage msg = new BrokeredMessage(order);
 16: 
 17:             /***********************
 18:             *** Send Operations  ***
 19:             ************************/
 20: 
 21:             queueClient.Send(msg);
 22: 
 23:             /**************************
 24:              *** Receive Operations ***
 25:             ***************************/
 26:             
 27:             BrokeredMessage recdMsg;
 28:             Order recdOrder;
 29: 
 30:             // Receive and lock message
 31:             recdMsg = queueClient.Receive();
 32: 
 33:             if(recdMsg != null)
 34:             {
 35:                 // Convert from BrokeredMessage to native Order
 36:                 recdOrder = recdMsg.GetBody<Order>();
 37: 
 38:                 Console.ForegroundColor = ConsoleColor.Green;
 39:                 Console.WriteLine("Received Order {0} \n\t with Message Id {1} \n\t and Lock Token:{2} \n\t from {3} \n\t with total of ${4}", recdOrder.OrderId, recdMsg.MessageId, recdMsg.LockToken, "Receiver 1", recdOrder.Total);
 40:                 recdMsg.Complete();
 41:             }
 42:             queueClient.Close();

Note that MessageSender and MessageReceiver are now optional. Here’s an example that shows PeekLocking a message, simulating an exception and trying again:

  1: 
  2:             // Alternate receive approach using agnostic MessageReceiver
  3:             MessageReceiver receiver = messagingFactory.CreateMessageReceiver(queueName);            // Recieve, complete, and delete message from the fabric
  4: 
  5:             try
  6:             {
  7:                 // Receive and lock message
  8:                 recdMsg = receiver.Receive();
  9: 
 10:                 // Convert from BrokeredMessage to native Order
 11:                 recdOrder = recdMsg.GetBody<Order>();
 12: 
 13:                 // Complete read, release and delete message from the fabric
 14:                 receiver.Complete(recdMsg.LockToken);
 15: 
 16:                 Console.ForegroundColor = ConsoleColor.Green;
 17:                 Console.WriteLine("Received Order {0} \n\t with Message Id {1} \n\t and Lock Token:{2} \n\t from {3} \n\t with total of ${4} \n\t at {5}", recdOrder.OrderId, recdMsg.MessageId, recdMsg.LockToken, "Receiver 2", recdOrder.Total, DateTime.Now.Hour + ":" + DateTime.Now.Minute + ":" + DateTime.Now.Second);
 18:             }
 19:             catch
 20:             {
 21:                 // Should processing fail, release the lock from the fabric and make message available for later processing.
 22:                 if (recdMsg != null)
 23:                 {
 24:                     receiver.Abandon(recdMsg.LockToken);
 25:                     
 26:                     Console.ForegroundColor = ConsoleColor.Red;
 27:                     Console.WriteLine("Message could not be processed.");
 28: 
 29:                 }
 30:             }
 31:             finally
 32:             {
 33:                 receiver.Close();
 34:             }

As shown below, this sample results in order 42 being received by the QueueClient:

Topics

May/June CTP	General Availability	Comments
Topic	TopicDescription	In May/June CTP, Topic / Queue / Subscription were management objects. All create/delete operations were moved to NamespaceManager and the state operations are now on TopicDescription/QueueDescription etc.
TopicClient	TopicClient	As noted in the Queues section, you can use TopicClient or MessageSender in the event you want to abstract details of using Topics.
SubscriptionClient	SubscriptionClient	As noted in the Queues section, you can use SubscriptionClient or MessageReceiver in the event you want to abstract details of using a Topic/Subscription.
Subscription	SubscriptionDescription	Changes to constructors and use of properties (see code samples below), but intent is the same.
RuleDescription	RuleDescription	Changes to constructors and use of properties (see code samples below), but intent is the same.
FilterExpression	Filter	Base for Filter types such as SqlFilter
SqlFilterExpression	SqlFilter
FilterAction	RuleAction

Below is a representative sample for creating, configuring, sending and receiving a message on a topic:

Administrative Operations

  1:             // Configure and create NamespaceManager for performing administrative operations
  2:             NamespaceManagerSettings settings = new NamespaceManagerSettings();
  3:             settings.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuer, key);
  4:             NamespaceManager manager = new NamespaceManager(ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty), settings);
  5: 
  6:             // Check for existence of topics on the fabric
  7:             var topics = manager.GetTopics();
  8: 
  9:             var result = from t in topics
 10:                          where t.Path.Equals(topicName, StringComparison.OrdinalIgnoreCase)
 11:                          select t;
 12: 
 13:             if (result.Count() == 0)
 14:             {
 15:                 Console.WriteLine("Topic does not exist");
 16: 
 17:                 // Create Queue
 18:                 Console.WriteLine("Creating Topic...");
 19: 
 20:                 TopicDescription topic = manager.CreateTopic(topicName);
 21:             }
 22: 
 23:             // Create Subscriptions for InventoryServiceSubscription and CreditServiceSubscription and associate to OrdersTopic:
 24:             SubscriptionDescription inventoryServiceSubscription = new SubscriptionDescription(topicName, "InventoryServiceSubscription");
 25:             SubscriptionDescription creditServiceSubscription = new SubscriptionDescription(topicName, "CreditServiceSubscription");
 26: 
 27: 
 28:             // Set up Filters for NorthAmericaFulfillmentServiceSubscription
 29:             RuleDescription northAmericafulfillmentRuleDescription = new RuleDescription();
 30:             northAmericafulfillmentRuleDescription.Filter = new SqlFilter("CountryOfOrigin = 'USA' OR CountryOfOrigin ='Canada' OR CountryOfOrgin ='Mexico'");
 31:             northAmericafulfillmentRuleDescription.Action = new SqlRuleAction("set FulfillmentRegion='North America'");
 32: 
 33: 
 34:             // Create Subscriptions
 35:             SubscriptionDescription northAmericaFulfillmentServiceSubscription = new SubscriptionDescription(topicName, "NorthAmericaFulfillmentServiceSubscription");
 36: 
 37:             // Delete existing subscriptions
 38:             try { manager.DeleteSubscription(topicName, inventoryServiceSubscription.Name); } catch { };
 39:             try { manager.DeleteSubscription(topicName, creditServiceSubscription.Name); } catch { };
 40:             try { manager.DeleteSubscription(topicName, northAmericaFulfillmentServiceSubscription.Name); } catch { };
 41: 
 42:             
 43:             // Add Subscriptions and Rules to Topic
 44:             manager.CreateSubscription(inventoryServiceSubscription);
 45:             manager.CreateSubscription(creditServiceSubscription);
 46:             manager.CreateSubscription(northAmericaFulfillmentServiceSubscription, northAmericafulfillmentRuleDescription);
 47:

Runtime Operations

  1:             // Create and Configure Messaging Factory to provision TopicClient
  2:             MessagingFactorySettings runtimeSettings = new MessagingFactorySettings();
  3:             runtimeSettings.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuer, key);
  4:             MessagingFactory messagingFactory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb",serviceNamespace,String.Empty),runtimeSettings);
  5:             
  6:             // Create Topic Client for sending messages to the Topic:
  7:             TopicClient client = messagingFactory.CreateTopicClient(topicName);
  8:          
  9:             /***********************
 10:              *** Send Operations ***
 11:              ***********************/
 12: 
 13:             // Prepare BrokeredMessage and corresponding properties
 14:             Order order = new Order();
 15:             order.OrderId = 42;
 16:             order.Products.Add("Kinect", 70.50M);
 17:             order.Products.Add("XBOX 360", 199.99M);
 18:             order.Total = order.Products["Kinect"] + order.Products["XBOX 360"];
 19: 
 20:             // Set the body to the Order data contract
 21:             BrokeredMessage msg = new BrokeredMessage(order);
 22:             
 23:             // Set properties for use in RuleDescription
 24:             msg.Properties.Add("CountryOfOrigin", "USA");
 25:             msg.Properties.Add("FulfillmentRegion", "");
 26:             
 27:             // Send the message to the OrdersTopic
 28:             client.Send(msg);
 29:             client.Close();
 30:             
 31:            /**************************
 32:              *** Receive Operations ***
 33:            ****************************/
 34:         
 35:             BrokeredMessage recdMsg;
 36:             Order recdOrder;
 37: 
 38:             // Inventory Service Subscriber
 39:             SubscriptionClient inventoryServiceSubscriber = messagingFactory.CreateSubscriptionClient(topicName, "InventoryServiceSubscription",ReceiveMode.PeekLock);
 40:             
 41:             // Read the message from the OrdersTopic
 42:             while ((recdMsg = inventoryServiceSubscriber.Receive(TimeSpan.FromSeconds(5))) != null)
 43:             {   
 44:                 // Convert from BrokeredMessage to native Order
 45:                 recdOrder = recdMsg.GetBody<Order>();
 46: 
 47:                 // Complete read, release and delete message from the fabric
 48:                 inventoryServiceSubscriber.Complete(recdMsg.LockToken);
 49: 
 50:                 Console.ForegroundColor = ConsoleColor.Green;
 51:                 Console.WriteLine("Received Order {0} \n\t on {1} \n\t with Message Id {2} \n\t and Lock Token {3}.", recdOrder.OrderId, "Inventory Service Subscriber", recdMsg.MessageId, recdMsg.LockToken);
 52:             }
 53:             inventoryServiceSubscriber.Close();
 54: 
 55:             // Credit Service Subscriber
 56:             SubscriptionClient creditServiceSubscriber = messagingFactory.CreateSubscriptionClient(topicName, "CreditServiceSubscription");
 57: 
 58:             // Read the message from the OrdersTopic
 59:             recdMsg = creditServiceSubscriber.Receive();
 60: 
 61:             // Convert from BrokeredMessage to native Order
 62:             recdOrder = recdMsg.GetBody<Order>();
 63: 
 64:             // Complete read, release and delete message from the fabric
 65:             creditServiceSubscriber.Complete(recdMsg.LockToken);
 66: 
 67:             Console.ForegroundColor = ConsoleColor.Green;
 68:             Console.WriteLine("Received Order {0} \n\t on {1} \n\t with Message Id {2} \n\t and Lock Token {3}.", recdOrder.OrderId, "Credit Service Subscriber", recdMsg.MessageId, recdMsg.LockToken);
 69: 
 70:             creditServiceSubscriber.Close();
 71: 
 72:             // Fulfillment Service Subscriber for the North America Fulfillment Service Subscription
 73:             SubscriptionClient northAmericaFulfillmentServiceSubscriber = messagingFactory.CreateSubscriptionClient(topicName, "northAmericaFulfillmentServiceSubscription");
 74:             
 75:             // Read the message from the OrdersTopic for the North America Fulfillment Service Subscription
 76:             recdMsg = northAmericaFulfillmentServiceSubscriber.Receive(TimeSpan.FromSeconds(5));
 77: 
 78:             
 79:            if(recdMsg != null)
 80:             {
 81:                 // Convert from BrokeredMessage to native Order
 82:                 recdOrder = recdMsg.GetBody<Order>();
 83: 
 84:                 // Complete read, release and delete message from the fabric
 85:                 northAmericaFulfillmentServiceSubscriber.Complete(recdMsg.LockToken);
 86: 
 87:                 Console.ForegroundColor = ConsoleColor.Green;
 88:                 Console.WriteLine("Received Order {0} \n\t on {1} \n\t with Message Id {2} \n\t and Lock Token {3}.", recdOrder.OrderId, "North America Fulfillment Service Subscriber", recdMsg.MessageId, recdMsg.LockToken);
 89:             }
 90:             else
 91:             {
 92:                 Console.ForegroundColor = ConsoleColor.Yellow;
 93:                 Console.WriteLine("No messages for North America found.");
 94:             }
 95:             
 96:             northAmericaFulfillmentServiceSubscriber.Close();

When running this sample, you’ll see that I have received Order 42 on my Inventory, Credit and North America Fulfillment Service subscriptions:

WCF

One of the great things about the WCF programming model is that it abstracts much of the underlying communication details and as such, other than dropping in a new assembly and and refactoring the binding and configuration, it is not greatly affected by the API changes from the May/June CTP to GA.

As I mentioned, one thing that has changed is that the ServiceBusMessagingBinding has been renamed to NetMessagingBinding. I’ll be covering and end to end example of using the NetMessagingBinding in my upcoming article in CODE Magazine.

REST API

The REST API is key to delivering these new capabilities across a variety of client platforms and remains largely unchanged, however one key change is how message properties are handled. Instead of individual headers for each, there is now one header with all the properties JSON encoded. Please refer to the updated REST API Reference doc for details. I’ll also be covering and end-to-end example of using the REST API to write an read to/from a queue in my upcoming article in CODE Magazine.

More Coming Soon

As I mentioned, in my upcoming article in CODE Magazine, I’ll cover the Why, What, and How behind Azure AppFabric Service Bus Brokered Messaging including end to end walkthroughs with the .NET Client API, REST API and WCF Binding. The November/December issue should be on newsstands (including Barnes and Noble) or your mailbox towards the end of October. You can also find the article online at http://code-magazine.com

Resources

You can learn more about this exciting release as well as download the GA SDK version 1.5 by visiting the following resources:

Azure AppFabric SDK 1.5:http://www.microsoft.com/download/en/details.aspx?id=27421
Clemens Vasters on the May CTP: http://vasters.com/clemensv/2011/05/16/Introducing+The+Windows+Azure+AppFabric+Service+Bus+May+2011+CTP.aspx
Great video by Clemens Vasters on Brokered Messaging: http://vasters.com/clemensv/2011/06/11/Understanding+Windows+Azure+AppFabric+Queues+And+Topics.aspx
David Ingham on Queues: http://blogs.msdn.com//b/appfabric/archive/2011/05/17/an-introduction-to-service-bus-queues.aspx
David Ingham on Topics: http://blogs.msdn.com//b/appfabric/archive/2011/05/25/an-introduction-to-service-bus-topics.aspx
My Introduction to Queues: http://rickgaribay.net/archive/2011/05/17/appfabric-service-bus-v2-ctp.aspx
My Introduction to Topics:http://rickgaribay.net/archive/2011/05/31/exploring-appfabric-service-bus-v2-may-ctp-topics.aspx