public void when_sending_message_async_then_succeeds()
{
var payload = Guid.NewGuid().ToString();
sut.SendAsync(() => new BrokeredMessage(payload));
var message = subscriptionClient.Receive(TimeSpan.FromSeconds(5));
Assert.Equal(payload, message.GetBody <string>());
}
protected void SubscriberTask <T>()
{
while (true)
{
BrokeredMessage message = _sc.Receive();
if (message != null)
{
T msg = message.GetBody <T>();
Console.WriteLine(msg);
message.Complete();
}
}
}
public JsonResult RetrieveMessage(string topicName, string subscriptionName)
{
SubscriptionClient subscriptionClient = this.messagingFactory.CreateSubscriptionClient(topicName, subscriptionName, ReceiveMode.PeekLock);
BrokeredMessage receivedMessage = subscriptionClient.Receive(new TimeSpan(0, 0, 30));
if (receivedMessage == null)
{
return(this.Json(null, JsonRequestBehavior.AllowGet));
}
var receivedCustomMessage = receivedMessage.GetBody <CustomMessage>();
var brokeredMsgProperties = new Dictionary <string, object>();
brokeredMsgProperties.Add("Size", receivedMessage.Size);
brokeredMsgProperties.Add("MessageId", receivedMessage.MessageId.Substring(0, 15) + "...");
brokeredMsgProperties.Add("TimeToLive", receivedMessage.TimeToLive.TotalSeconds);
brokeredMsgProperties.Add("EnqueuedTimeUtc", receivedMessage.EnqueuedTimeUtc.ToString("yyyy-MM-dd HH:mm:ss"));
brokeredMsgProperties.Add("ExpiresAtUtc", receivedMessage.ExpiresAtUtc.ToString("yyyy-MM-dd HH:mm:ss"));
var messageInfo = new
{
Label = receivedMessage.Label,
Date = receivedCustomMessage.Date,
Message = receivedCustomMessage.Body,
Properties = receivedMessage.Properties.ToArray(),
BrokeredMsgProperties = brokeredMsgProperties.ToArray()
};
receivedMessage.Complete();
var subscription = this.namespaceManager.GetSubscription(topicName, subscriptionName);
return(this.Json(new { MessageInfo = messageInfo, MessagesInSubscription = subscription.MessageCount }, JsonRequestBehavior.AllowGet));
}
public T Receive <T>()
{
var message = m_SubscriptionClient.Receive();
var result = message.GetBody <T>();
return(result);
}
private static void TopicReceive(int subscription)
{
var topicName = "topicdemo";
var subToProcess = "Subscription" + subscription;
var connection = "Endpoint=sb://alewife.servicebus.windows.net/;SharedAccessKeyName=Receiver;SharedAccessKey=Vqa3SwP4qH5/+8ikB4B/BNMPQCRDuV/AiUYsUofWebo=;TransportType=Amqp";
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connection);
SubscriptionClient clientA = factory.CreateSubscriptionClient(topicName, subToProcess);
while (true)
{
BrokeredMessage message = clientA.Receive();
if (message != null)
{
try
{
Console.WriteLine("MessageId:{0}", message.MessageId);
Console.WriteLine(message.GetBody <string>());
message.Complete();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
message.Abandon();
}
}
}
}
static void Main(string[] args)
{
TopicConnector.Initialize();
var messagingFactory = TopicConnector.messagingFactory;
//create two subscription clients to receive topic massage
SubscriptionClient agentSubscriptionClient = messagingFactory.CreateSubscriptionClient(TopicConnector.TopicName, "Inventory", ReceiveMode.PeekLock);
SubscriptionClient auditSubscriptionClient = messagingFactory.CreateSubscriptionClient(TopicConnector.TopicName, "Dashboard", ReceiveMode.ReceiveAndDelete);
var message1 = new BrokeredMessage();
while ((message1 = agentSubscriptionClient.Receive()) != null)
{
//deserialize Json data
message1.ContentType = "application/json";
var ms = new MemoryStream(Encoding.Unicode.GetBytes(message1.GetBody <string>()));
DataContractJsonSerializer deserializer = new DataContractJsonSerializer(typeof(OnlineOrder));
ms.Position = 0;
OnlineOrder order = (OnlineOrder)deserializer.ReadObject(ms);
Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1} {2}", message1.MessageId, order.Customer, order.Product));
message1.Complete();
}
var message2 = new BrokeredMessage();
while ((message2 = auditSubscriptionClient.Receive()) != null)
{
message2.ContentType = "application/json";
var ms = new MemoryStream(Encoding.Unicode.GetBytes(message2.GetBody <string>()));
DataContractJsonSerializer deserializer = new DataContractJsonSerializer(typeof(OnlineOrder));
ms.Position = 0;
OnlineOrder order = (OnlineOrder)deserializer.ReadObject(ms);
Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1} {2}", message2.MessageId, order.Customer, order.Product));
}
Console.ReadLine();
}
static void ReceiveAllMessageFromSubscription(MessagingFactory messagingFactory, string subsName)
{
int receivedMessages = 0;
// Create subscription client.
SubscriptionClient subsClient =
messagingFactory.CreateSubscriptionClient(Program.TopicName, subsName, ReceiveMode.ReceiveAndDelete);
// Create a receiver from the subscription client and receive all messages.
Console.WriteLine("\nReceiving messages from subscription {0}.", subsName);
while (true)
{
BrokeredMessage receivedMessage;
receivedMessage = subsClient.Receive(TimeSpan.FromSeconds(10));
if (receivedMessage != null)
{
receivedMessage.Dispose();
receivedMessages++;
}
else
{
// No more messages to receive.
break;
}
}
Console.WriteLine("Received {0} messages from subscription {1}.", receivedMessages, subsClient.Name);
}
static void Main(string[] args)
{
Console.Title = "Cheap Purchases Subscriber";
SubscriptionClient subscriptionClient = SubscriptionClient.Create("productsalestopic", "CheapPurchases");
// Continuously process messages received from the ExpensivePurchases subscription
while (true)
{
BrokeredMessage message = subscriptionClient.Receive();
if (message != null)
{
try
{
Console.WriteLine("Received purchase: Message id: {0}, Product name: {1}, Product price: {2}.", message.MessageId, message.Properties["ProductName"], message.Properties["ProductPrice"]);
// Remove printed message from subscription
message.Complete();
}
catch (Exception)
{
// In case of an error, unlock the message in subscription
message.Abandon();
}
}
}
}
public string RecieveMesageFromTopic(string Subscription)
{
String messageText = string.Empty;
SubscriptionClient Client = SubscriptionClient.CreateFromConnectionString
(_connectionString, _topic, Subscription);
var message = Client.Receive();
messageText = message.GetBody <string>();
message.Complete();
// Configure the callback options.
//OnMessageOptions options = new OnMessageOptions();
//options.AutoComplete = false;
//options.AutoRenewTimeout = TimeSpan.FromMinutes(1);
//Client.OnMessage((message) =>
//{
// try
// {
// messageText = message.GetBody<string>();
// // Remove message from subscription.
// message.Complete();
// }
// catch (Exception)
// {
// // Indicates a problem, unlock message in subscription.
// message.Abandon();
// }
//}, options);
return(messageText);
}
public async Task Run(OnMessageOptions topicOptions)
{
while (true)
{
var message = _deadLetter.Receive();
if (message == null)
{
break;
}
var context = message.GetBody <RemoteExecutionContext>(CrmPluginBrokerRole.ExecutionContextSerializer);
try
{
await PassContextToPlugins(context);
}
catch (Exception)
{
Trace.TraceError("Failing dead-letter message: {0}({1}) {2}",
context.PrimaryEntityName,
context.PrimaryEntityId,
context.MessageName);
throw;
}
}
_deadLetter.Close();
_topic.OnMessageAsync(OnTopicMessageAsync, topicOptions);
}
private static void ReceiveFromSubscriptions(string topicPath)
{
// Create a SubscriptionClient
SubscriptionClient subClient =
Factory.CreateSubscriptionClient(topicPath, JobType.Testing.ToString());
while (true)
{
// Recieve any message with a one second timeout.
BrokeredMessage msg = subClient.Receive(TimeSpan.FromSeconds(1));
if (msg != null)
{
// Deserialize the message body to an order.
var job = msg.GetBody <Job>();
Console.WriteLine(job.ToString());
// Mark the message as complete.
msg.Complete();
}
else
{
//Console.WriteLine();
//break;
}
}
//subClient.Close();
}
public Message <T> Receive <T>(TimeSpan timeout)
{
try
{
BrokeredMessage brokeredMessage = subscriptionClient.Receive(timeout);
if (brokeredMessage == null)
{
return(null);
}
T payload;
try
{
payload = brokeredMessage.GetBody <T>();
}
catch
{
payload = default(T);
}
return(new WindowsServiceBusMessage <T>(payload, brokeredMessage));
}
catch (Exception ex)
{
throw new MessagingException(
"An error occurred while attempting to read a message from the specified subscription. See inner exception for more details.",
ex);
}
}
static void Receive(MessagingFactory factory)
{
SubscriptionClient agentSubscriptionClient = factory.CreateSubscriptionClient(Program.IssueTrackingTopic, Program.AgentSubscription, ReceiveMode.PeekLock);
SubscriptionClient auditSubscriptionClient = factory.CreateSubscriptionClient(Program.IssueTrackingTopic, Program.AuditSubscription, ReceiveMode.ReceiveAndDelete);
//*****************************************************************************************************
// Receiving messages from a Subscription
//*****************************************************************************************************
BrokeredMessage message;
Console.WriteLine("\nReceiving message from AgentSubscription...");
while ((message = agentSubscriptionClient.Receive(TimeSpan.FromSeconds(5))) != null)
{
Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1}", message.MessageId, message.GetBody <string>()));
// Further custom message processing could go here...
message.Complete();
}
// Create a receiver using ReceiveAndDelete mode
Console.WriteLine("\nReceiving message from AuditSubscription...");
while ((message = auditSubscriptionClient.Receive(TimeSpan.FromSeconds(5))) != null)
{
Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1}", message.MessageId, message.GetBody <string>()));
// Further custom message processing could go here...
}
}
private string GetEventID()
{
string result = "";
InitTopic(); //Topicの初期化
//Subscription Clientインスタンスの作成
SClient = SubscriptionClient.
CreateFromConnectionString(connectionString,
TopicName, subscripitionname);
//Subscriptionからメッセージを受信
BrokeredMessage msg
= SClient.Receive(TimeSpan.FromSeconds(3));
if (msg != null)
{
//メッセージを取得できた場合、本文を戻り値に設定
result = msg.GetBody <string>();
msg.Complete();
}
else
{
//取得できない場合、404を返す
this.StatusCode(HttpStatusCode.NotFound);
result = "0000";
}
return(result);
}
private static void CreateSubscription(NamespaceManager namespaceManager, MessagingFactory messagingFactory, string topicName, string subscriptionName)
{
Guid subscriberId = Guid.NewGuid();
TopicDescription topicDescription = namespaceManager.GetTopic(topicName);
SubscriptionDescription subscription = null;
if (!namespaceManager.SubscriptionExists(topicDescription.Path, subscriptionName))
{
subscription = namespaceManager.CreateSubscription(topicDescription.Path, subscriptionName);
}
else
{
subscription = namespaceManager.GetSubscription(topicDescription.Path, subscriptionName);
}
Task.Factory.StartNew(() => {
SubscriptionClient subscriptionClient = messagingFactory.CreateSubscriptionClient(topicDescription.Path, subscription.Name);
BrokeredMessage message = null;
while ((message = subscriptionClient.Receive(TimeSpan.FromSeconds(30))) != null)
{
Console.WriteLine("Subscriber {0} - Receiving message from subscription '{1}': {2}", subscriberId, subscriptionName, message.GetBody <string>());
message.Complete();
}
}, TaskCreationOptions.LongRunning);
}
public void getQueueValue(string strEndpoint, string strTopicName, string subscriptionName)
{
var connectionString = strEndpoint;
var queueName = strTopicName;
ViewBag.Endpoint = connectionString;
ViewBag.QueueName = queueName;
SubscriptionClient client = SubscriptionClient.CreateFromConnectionString(strEndpoint, strTopicName, subscriptionName);
var msg3 = "";
BrokeredMessage message = null;
NamespaceManager namespaceManager = NamespaceManager.Create();
while (true)
{
try
{
//receive messages from Queue
message = client.Receive(TimeSpan.FromSeconds(5));
ViewBag.Msg12 = "No active message is avilable in service bus queue.";
if (message != null)
{
//Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1}", message.MessageId, message.GetBody<string>()));
var t = message.MessageId;
if (msg3 == "")
{
msg3 = message.GetBody <string>();
}
else
{
msg3 = msg3 + ", " + message.GetBody <string>();
}
message.Complete();
ViewBag.Msg12 = "";
// break;
}
else
{
//msg3 = "";
break;
}
}
catch (MessagingException e)
{
if (!e.IsTransient)
{
Console.WriteLine(e.Message);
throw;
}
else
{
//HandleTransientErrors(e);
}
}
}
client.Close();
ViewBag.Qmsg4 = msg3;
}
private void ReadMessageValue(SubscriptionClient subsClient)
{
if (subsClient == null)
{
throw new ArgumentNullException("subsClient");
}
while (true)
{
//Receive any message with a one second timeout
var msg = subsClient.Receive(TimeSpan.FromSeconds(1));
if (msg != null)
{
//Deserialize the message body
var order = msg.GetBody <Order>();
ProcessOrder(order);
//Mark the message as complete
msg.Complete();
}
else
{
break;
}
}
}
private void Listen()
{
while (_isInRunningState)
{
try
{
BrokeredMessage message;
while ((message = _subscriptionClient.Receive(TimeSpan.FromSeconds(30))) != null)
{
// Process message from queue
System.Console.WriteLine("Body: {0}", message.GetBody <string>());
System.Console.WriteLine("Label: {0}", message.Label);
System.Console.WriteLine("MessageID: {0}", message.MessageId);
System.Console.WriteLine("'From' Property: {0}\n", message.Properties["From"]);
// Remove message from queue
message.Complete();
}
}
catch (Exception)
{
// handle internal errors as usual
// special care needs to be taken if SB Connection dies
throw;
}
}
}
public override BrokeredMessage ReceiveNextMessage(string topicName, TimeSpan timeout, bool autoAcknowledge = false)
{
if (!_isInitialised)
{
Initialise(topicName);
}
if (_subscriptionClient == null)
{
_subscriptionClient = SubscriptionClient.Create(topicName, subscriptionName);
}
BrokeredMessage message = null;
try {
message = _subscriptionClient.Receive(timeout);
if (message == null)
{
return(null);
}
if (!autoAcknowledge)
{
return(message);
}
message.Complete();
}
catch (Exception) {
if (message != null)
{
message.Abandon();
}
throw;
}
return(message);
}
// Delete the first published message from service bus subscription
public void RemoveFirstPublishedMessage(string ServiceBusConnectionString, string TopicName, string SubscriptionName)
{
// Create service Bus namespace manager
var namespaceManager = NamespaceManager.CreateFromConnectionString(ServiceBusConnectionString);
// Get subscrition information of the topic
var subscriptionDesc = namespaceManager.GetSubscription(TopicName, SubscriptionName);
// Check number of published messages
long messageCount = subscriptionDesc.MessageCount;
// Skip removing message if none exists
if (messageCount != 0)
{
// Create service bus messageing factory
Factory = MessagingFactory.CreateFromConnectionString(ServiceBusConnectionString);
// Create subscription client for the topic
SubscriptionClient mySubscriptionClient = Factory.CreateSubscriptionClient(TopicName, SubscriptionName);
// Get first broker message from the subscription.
// Use Receive function
BrokeredMessage MessageReceived = mySubscriptionClient.Receive();
// Use lock token of the received brokered message to mark the message is completed.
// The message will be removed from the subscription
mySubscriptionClient.Complete(MessageReceived.LockToken);
//Clean up
MessageReceived.Dispose();
mySubscriptionClient.Close();
}
}
/// <summary>
/// Receives messages that the sales department send when a Clothes sales order is built.
/// </summary>
/// <returns></returns>
static bool ReceiveMessage()
{
bool blnRet = false;
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(strServiceBusConnect);
IEnumerable <SubscriptionDescription> lstSub = namespaceManager.GetSubscriptions(strTopic);
ThreadPool.SetMaxThreads(lstSub.Count(), lstSub.Count());
foreach (SubscriptionDescription sub in lstSub)
{
if (sub.Name.Contains("Clothes"))
{
SubscriptionClient subClient = SubscriptionClient.CreateFromConnectionString(strServiceBusConnect, strTopic, sub.Name);
while (true)
{
try
{
BrokeredMessage message = null;
message = subClient.Receive();
if (message != null)
{
string strCustomer = "";
string strSalesOrder = "";
string strSalesOrderDetails = "";
if (message.Properties.ContainsKey("Customer") && message.Properties["Customer"] != null)
{
strCustomer = message.Properties["Customer"].ToString();
}
if (message.Properties.ContainsKey("SalesOrder") && message.Properties["SalesOrder"] != null)
{
strSalesOrder = message.Properties["SalesOrder"].ToString();
}
if (message.Properties.ContainsKey("SalesOrderDetails") && message.Properties["SalesOrderDetails"] != null)
{
strSalesOrderDetails = message.Properties["SalesOrderDetails"].ToString();
}
if (!string.IsNullOrEmpty(strCustomer) && !string.IsNullOrEmpty(strSalesOrder) && !string.IsNullOrEmpty(strSalesOrderDetails))
{
Customer customer = (Customer)Deserialize(strCustomer, typeof(Customer));
SalesOrder salesOrder = (SalesOrder)Deserialize(strSalesOrder, typeof(SalesOrder));
List <SalesOrderProductDetails> lstOrderDetails = (List <SalesOrderProductDetails>)Deserialize(strSalesOrderDetails, typeof(List <SalesOrderProductDetails>));
if (SaveMessage(customer, salesOrder, lstOrderDetails))
{
message.Complete();
}
}
}
}
catch (Exception ex)
{
// throw ex;
}
}
}
}
return(blnRet);
}
static void Main(string[] args)
{
// The connection string for the RootManageSharedAccessKey can be accessed from the Azure portal
// by selecting the SB namespace and clicking on "Connection Information"
Console.Write("Enter your connection string for the RootManageSharedAccessKey for your Service Bus namespace: ");
nsConnectionString = Console.ReadLine();
///////////////////////////////////////////////////////////////////////////////////////
// Create a topic with a SAS Listen rule and an associated subscription
///////////////////////////////////////////////////////////////////////////////////////
NamespaceManager nm = NamespaceManager.CreateFromConnectionString(nsConnectionString);
contosoTListenRule = new SharedAccessAuthorizationRule("contosoTListenKey",
SharedAccessAuthorizationRule.GenerateRandomKey(),
new[] { AccessRights.Listen });
TopicDescription td = new TopicDescription(topicPath);
td.Authorization.Add(contosoTListenRule);
nm.CreateTopic(td);
nm.CreateSubscription(topicPath, subscriptionName);
///////////////////////////////////////////////////////////////////////////////////////
// Send a message to the topic
// Note that this uses the connection string for RootManageSharedAccessKey
// configured on the namespace root
///////////////////////////////////////////////////////////////////////////////////////
MessagingFactory sendMF = MessagingFactory.CreateFromConnectionString(nsConnectionString);
TopicClient tc = sendMF.CreateTopicClient(topicPath);
BrokeredMessage sentMessage = CreateHelloMessage();
tc.Send(sentMessage);
Console.WriteLine("Sent Hello message to topic: ID={0}, Body={1}.", sentMessage.MessageId, sentMessage.GetBody <string>());
///////////////////////////////////////////////////////////////////////////////////////
// Generate a SAS token scoped to a subscription using the SAS rule with
// a Listen right configured on the Topic & TTL of 1 day
///////////////////////////////////////////////////////////////////////////////////////
ServiceBusConnectionStringBuilder csBuilder = new ServiceBusConnectionStringBuilder(nsConnectionString);
IEnumerable <Uri> endpoints = csBuilder.Endpoints;
string subscriptionUri = endpoints.First <Uri>().ToString() + topicPath + "/subscriptions/" + subscriptionName;
string subscriptionToken = SASTokenGenerator.GetSASToken(subscriptionUri,
contosoTListenRule.KeyName, contosoTListenRule.PrimaryKey, TimeSpan.FromDays(1));
///////////////////////////////////////////////////////////////////////////////////////
// Use the SAS token scoped to a subscription to receive the messages
///////////////////////////////////////////////////////////////////////////////////////
MessagingFactory listenMF = MessagingFactory.Create(endpoints, new StaticSASTokenProvider(subscriptionToken));
SubscriptionClient sc = listenMF.CreateSubscriptionClient(topicPath, subscriptionName);
BrokeredMessage receivedMessage = sc.Receive(TimeSpan.FromSeconds(10));
Console.WriteLine("Received message from subscription: ID = {0}, Body = {1}.", receivedMessage.MessageId, receivedMessage.GetBody <string>());
///////////////////////////////////////////////////////////////////////////////////////
// Clean-up
///////////////////////////////////////////////////////////////////////////////////////
nm.DeleteTopic(topicPath);
}
private static void ReceiveAndNotify()
{
SubscriptionClient agentSubscriptionClient = SubscriptionClient.Create("tempdata", "AgentSubscription");
BrokeredMessage message = null;
var toastMessage = @"<toast activationType='foreground' launch='args'>
<visual><binding template=""ToastGeneric"">
<text id=""1"">{messagepayload}</text>
</binding></visual>
<actions>
<action content='Dismiss' activationType='foreground' arguments='check'/>
<action content='Take Action' activationType='foreground' arguments='cancel'/>
</actions></toast>";
while (true)
{
try
{
//receive messages from Agent Subscription
message = agentSubscriptionClient.Receive();
if (message != null)
{
Console.WriteLine("\nReceiving message from AgentSubscription...");
//The Storm bolt converts string to stream. Need to convert back.
var stream = message.GetBody <Stream>();
StreamReader reader = new StreamReader(stream);
string messageBody = reader.ReadToEnd();
toastMessage = toastMessage.Replace("{messagepayload}", messageBody);
//Send notification
SendNotificationAsync(toastMessage);
// Remove message from subscription
message.Complete();
}
else
{
//no more messages in the subscription
break;
}
}
catch (MessagingException e)
{
if (!e.IsTransient)
{
Console.WriteLine(e.Message);
throw;
}
else
{
HandleTransientErrors(e);
}
}
}
}
static void ReceiveMessageAndSendNotification(string connectionString)
{
// Initialize the Notification Hub
string hubConnectionString = CloudConfigurationManager.GetSetting
("Microsoft.NotificationHub.ConnectionString");
hub = NotificationHubClient.CreateClientFromConnectionString
(hubConnectionString, "[hubName]");
SubscriptionClient Client =
SubscriptionClient.CreateFromConnectionString
(connectionString, sampleTopic, sampleSubscription);
Client.Receive();
// Continuously process messages received from the subscription
while (true)
{
BrokeredMessage message = Client.Receive();
var toastMessage = @"<toast><visual><binding template=""ToastText01""><text id=""1"">{messagepayload}</text></binding></visual></toast>";
if (message != null)
{
try
{
Console.WriteLine(message.MessageId);
Console.WriteLine(message.SequenceNumber);
string messageBody = message.GetBody <string>();
Console.WriteLine("Body: " + messageBody + "\n");
toastMessage = toastMessage.Replace("{messagepayload}", messageBody);
SendNotificationAsync(toastMessage);
// Remove message from subscription
message.Complete();
}
catch (Exception)
{
// Indicate a problem, unlock message in subscription
message.Abandon();
}
}
}
}
private async Task RunAsync()
{
BrokeredMessage receivedMessage = null;
while (!IsStopped)
{
try
{
// Receive the message
receivedMessage = SubClient.Receive();
if (receivedMessage != null)
{
Order orderDetails = receivedMessage.GetBody <Order>();
Order order = new Order();
order.CustomerName = orderDetails.CustomerName;
order.EmailId = orderDetails.EmailId;
order.ProductOrderDetailsList = orderDetails.ProductOrderDetailsList;
order.OrderDate = orderDetails.OrderDate;
order.TotalDue = orderDetails.TotalDue;
order.orderStatus = "Processed";
// Remove message from subscription
receivedMessage.Complete();
order.OrderId = Guid.NewGuid();
await azureDocDBHelper.AddDocument(order, "OrderDetails");
receivedMessage = null;
}
}
catch (MessagingException e)
{
if (null != receivedMessage)
{
//unlock message in subscription
receivedMessage.Abandon();
}
if (!e.IsTransient)
{
Trace.WriteLine(e.Message);
throw;
}
Thread.Sleep(10000);
}
catch (Exception ex)
{
// unlock message in subscription
receivedMessage.Abandon();
Trace.WriteLine(ex.Message);
}
}
}
private void CommitOffset(SubscriptionClient subscriptionClient, long sequenceNumber)
{
try
{
var toCompleteMessage = subscriptionClient.Receive(sequenceNumber);
toCompleteMessage.Complete();
}
catch (Exception ex)
{
_logger.Error($"subscriptionClient commit offset {sequenceNumber} failed", ex);
}
}
public static string GetCustomerDataFromSubscription(string topicName, string subscriptionName)
{
//NamespaceManager manager = NamespaceManager.CreateFromConnectionString(_azureConnStr);
//var subscriptions = manager.GetSubscriptions(topicName);
SubscriptionClient sbClient = SubscriptionClient.CreateFromConnectionString(_azureConnStr, topicName, subscriptionName);
BrokeredMessage message = sbClient.Receive();
var custData = message.Properties["Customer"].ToString();
message.Complete();
sbClient.Close();
return(custData);
}
public IMessageContext <T> Receive(TimeSpan?timeout = null)
{
var message = ((timeout.HasValue)
? (SubscriptionClient.Receive(timeout.Value))
: (SubscriptionClient.Receive()));
if (message == null)
{
return(null);
}
return(new AzureBrokeredMessageContext <T>(message, message.GetBody <T>()));
}
public void Run()
{
InitializeSubscriptionClient();
var entitiesContext = new EntitiesContext();
ITemperatureAggregateService temperatureAggregateService = new TemperatureAggregateService(
new EntityRepository <TemperatureAggregate>(entitiesContext), new EntityRepository <Brew>(entitiesContext));
while (true)
{
Trace.WriteLine("Receiving message...", "Info");
var brokeredMessage = _subscriptionClient.Receive();
if (brokeredMessage != null)
{
Trace.WriteLine("Received message.", "Info");
Trace.WriteLine(
string.Format("Message id: {0} - Message enqueued: {1}", brokeredMessage.MessageId,
brokeredMessage.EnqueuedTimeUtc), "Verbose");
SensorReading sensorReading = null;
// We support two message types: a serialized SensorReading and one that only sends us
// message properties (for netmf support). Let's see what we have...
if (brokeredMessage.Properties.Any() && brokeredMessage.Properties.ContainsKey("SensorId"))
{
sensorReading = new SensorReading
{
SensorId = (string)brokeredMessage.Properties["SensorId"],
When = new DateTime(Convert.ToInt64(brokeredMessage.Properties["When"]), DateTimeKind.Utc),
Value = Convert.ToDouble(brokeredMessage.Properties["Value"], CultureInfo.CreateSpecificCulture("en-US"))
};
if (sensorReading.When.Year > (DateTime.UtcNow.Year + 1) || sensorReading.When.Year < DateTime.UtcNow.Year)
{
sensorReading.When = brokeredMessage.EnqueuedTimeUtc;
}
}
else
{
sensorReading = brokeredMessage.GetBody <SensorReading>();
}
Trace.WriteLine(string.Format("Message id: {0} - Sensor: {1} - Sensor reading: {2}", brokeredMessage.MessageId, sensorReading.SensorId, sensorReading.Value), "Verbose");
Trace.WriteLine("Processing message...", "Info");
temperatureAggregateService.AggregateData(sensorReading.SensorId, sensorReading.When, sensorReading.Value);
brokeredMessage.Complete();
Trace.WriteLine("Processed message.", "Info");
}
}
}
public override void CommitOffset(IMessageContext messageContext)
{
var sequenceNumber = messageContext.Offset;
try
{
var toCompleteMessage = _subscriptionClient.Receive(sequenceNumber);
toCompleteMessage.Complete();
}
catch (Exception ex)
{
_logger.Error($"queueClient({Id}) commit offset {sequenceNumber} failed", ex);
}
}
static void ReceiveAllMessagesFromSubscription(SubscriptionClient myTopicClient)
{
while (true)
{
var message = myTopicClient.Receive(TimeSpan.FromSeconds(5));
if (message != null)
{
Console.WriteLine("Message received. Id: {0} Body: {1}", message.MessageId, message.GetBody<string>());
}
else
{
Console.WriteLine("No more messages");
return;
}
}
}
public override void Run()
{
string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
Client = SubscriptionClient.CreateFromConnectionString(connectionString, TopicName, "OrderProcessingSubscription");
BrokeredMessage message = null;
while (!IsStopped)
{
try
{
// Receive the message
BrokeredMessage receivedMessage = null;
receivedMessage = Client.Receive();
if (receivedMessage != null)
{
// Process the message
Trace.WriteLine("Processing", receivedMessage.SequenceNumber.ToString());
OnlineOrder order = receivedMessage.GetBody<OnlineOrder> ();
Trace.WriteLine(order.Customer + ": " + order.Product, "ProcessingMessage");
receivedMessage.Complete();
}
}
catch (MessagingException e)
{
if (!e.IsTransient)
{
Trace.WriteLine(e.Message);
throw;
}
Thread.Sleep(10000);
}
catch (OperationCanceledException e)
{
if (!IsStopped)
{
Trace.WriteLine(e.Message);
throw;
}
}
}
}
private void StartReceivingMessages(SubscriptionClient client, TextBox textBox)
{
var worker = new BackgroundWorker();
worker.DoWork += delegate(object sender, DoWorkEventArgs e)
{
while (true)
{
var brokeredMessage = client.Receive(TimeSpan.FromSeconds(1));
if (brokeredMessage != null)
{
var twitt = brokeredMessage.GetBody<Twitt>();
textBox.Text += string.Format("<{0}>{1}{2}", twitt.TimeStamp.ToString("dd/MM/yyyy HH:mm"), twitt.Content, Environment.NewLine);
}
}
};
worker.RunWorkerAsync();
}
