static void SendMessages(TopicClient topicClient, SubscriptionClient responseClient) { // Send request messages to queue: Console.WriteLine("Sending request messages to topic {0}", topicClient.Path); Console.WriteLine("Receiving response messages on subscription {0}", responseClient.Name); MessageSession session = responseClient.AcceptMessageSession(ClientId); for (int i = 0; i < SampleManager.NumMessages; ++i) { // send request message BrokeredMessage message = new BrokeredMessage { ReplyToSessionId = ClientId, MessageId = i.ToString(), CorrelationId = SampleManager.RequestSubName }; topicClient.Send(message); SampleManager.OutputMessageInfo("REQUEST: ", message); // start asynchronous receive operation //TODO: Fix //session.ReceiveAsync ( TimeSpan.FromSeconds(ResponseMessageTimeout), ProcessResponse, session); var brokeredMessage = session.Receive(TimeSpan.FromSeconds(ResponseMessageTimeout)); ProcessResponse(brokeredMessage); } Console.WriteLine(); }
public void ProcessSessionSubscription(SubscriptionClient subscriptionClient, TopicClient destinationTopicClient) { _activityLogger.Log($"[{subscriptionClient.TopicPath}].[{subscriptionClient.Name}] - Processing subscription requiring a session"); var totalMessagesForwarded = 0; var messageSessions = subscriptionClient.GetMessageSessions(); if (messageSessions.Any()) { var sessionIds = new List <string>(); // obtain session IDs and then close these sessions, as they are browse-only foreach (var messageSession in messageSessions) { sessionIds.Add(messageSession.SessionId); messageSession.Close(); } foreach (var sessionId in sessionIds) { _activityLogger.Log($"[{subscriptionClient.TopicPath}].[{subscriptionClient.Name}] - Processing subscription session ID: {sessionId} "); var messagesRemaining = true; while (messagesRemaining) { var messageSession = subscriptionClient.AcceptMessageSession(sessionId, _serverWaitTime); var messages = messageSession.ReceiveBatch(_messagesToHandle, _serverWaitTime); var messageCount = messages.Count(); if (messageCount > 0) { _activityLogger.Log($"Batch of {messageCount} message(s) received for processing", 1); var messagesForwarded = 0; foreach (var message in messages) { if (!_forwardedMessageIds.Contains(message.MessageId)) // ignore duplicate messages, which have already been forwarded { // log message _messageLogger?.Log($"Subscription: [{subscriptionClient.TopicPath}].[{subscriptionClient.Name}]\n" + $"{message.GetSingleLineContent()}\n"); // send messages to destination topic destinationTopicClient.Send(message.Clone()); _forwardedMessageIds.Add(message.MessageId); messagesForwarded++; totalMessagesForwarded++; } message.Complete(); } _activityLogger.Log($"Processing complete: {messagesForwarded} message(s) forwarded " + $"({messageCount - messagesForwarded} duplicate(s) from other subscriptions)", 1); } else { messagesRemaining = false; _activityLogger.Log($"No {(totalMessagesForwarded > 0 ? "more " : "")}messages to process in this session", 1); } messageSession.Close(); } } } else { _activityLogger.Log("No sessions exist - no messages to forward", 1); } _activityLogger.Log($"[{subscriptionClient.TopicPath}].[{subscriptionClient.Name}] - Completed processing subscription - {totalMessagesForwarded} message(s) forwarded"); }
static public BrokeredMessage ReceiveLargeMessage(SubscriptionClient client) { // Create a memory stream to store the large message body. var largeMessageStream = new MemoryStream(); // Accept a message session from the queue. MessageSession session; try { session = client.AcceptMessageSession(TimeSpan.FromSeconds(5)); } catch (TimeoutException) { //If getting a session times out, just return from the method. //This timeout generally means there were no session-ful messages waiting return(null); } var noMoreMessagesAvailable = false; //Set to an absurdly high value initially. Will be set to the correct count after the first message is received int totalNumMessages = int.MaxValue; int numMessagesReceived = 0; //Keep a list of the messages so we can Complete them once we've received all var subMessages = new List <BrokeredMessage>(); while ((numMessagesReceived < totalNumMessages) && !noMoreMessagesAvailable) { // Receive a sub message var subMessage = session.Receive(TimeSpan.FromSeconds(5)); if (subMessage != null) { if (subMessage.Properties.ContainsKey("TotalCount")) { totalNumMessages = (int)subMessage.Properties["TotalCount"]; } // Copy the sub message body to the large message stream. var subMessageStream = subMessage.GetBody <Stream>(); subMessageStream.CopyTo(largeMessageStream); // Mark the message as complete. //subMessage.Complete(); subMessages.Add(subMessage); numMessagesReceived++; } else { //Bail out of the loop if no more messages are found. Note: this waits on the 5 second timeout. noMoreMessagesAvailable = true; } } //If we didn't receive all the messages, abandon so they'll be picked up again if (numMessagesReceived != totalNumMessages) { foreach (var message in subMessages) { message.Abandon(); } return(null); } //If we did receive all the messages, then complete them foreach (var message in subMessages) { message.Complete(); } // Create an aggregated message from the large message stream. var largeMessage = new BrokeredMessage(largeMessageStream, true); return(largeMessage); }