private static async Task CleanUpEntity(string connectionString, string entityPAth) { var client = new SessionClient(connectionString, entityPAth, ReceiveMode.PeekLock); client.OperationTimeout = TimeSpan.FromSeconds(5); IMessageSession session = null; try { session = await client.AcceptMessageSessionAsync(); var messages = await session.ReceiveAsync(1000, TimeSpan.FromSeconds(1)); await session.CompleteAsync(messages.Select(m => m.SystemProperties.LockToken)); } catch (ServiceBusException) { } finally { if (session != null) { await session.CloseAsync(); } } }
static async Task ProcessStatusMessagesAsync(IMessageSession session, Message message, CancellationToken token) { dynamic msg = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(message.Body)); lock (Console.Out) { Console.ForegroundColor = ConsoleColor.DarkYellow; Console.WriteLine( "Status message received:" + "\n\tContent: [ Name = {0}, status = {1} ]", msg.name, msg.status); Console.ResetColor(); } await session.CompleteAsync(message.SystemProperties.LockToken); if (msg.step == 5) { // end of the session! await session.CloseAsync(); Console.WriteLine("\n\t********** END OF SESSION *************"); } }
public async Task ProcessWorkItem_Session_ServiceBus( [ServiceBusSessionTrigger("test-session-queue")] WorkItem message, string lockToken, string messageId, int deliveryCount, IMessageSession messageSession, ILogger log) { try { //check session instance correlation if (messageSession.SessionId != message.SessionId) { throw new System.Exception("Session Id conflict"); } log.LogInformation($"Processing ServiceBus message (Id={messageId}, DeliveryCount={deliveryCount})"); _sessionState.AddOrUpdate(message.SessionId, message.Step); await Task.Delay(100); log.LogInformation($"Message complete (Id={messageId})"); await messageSession.CompleteAsync(lockToken); // SessionHandlerOptions.AutoComplete should be false by default to accomplish session close manually (when any business condition is verified) if (message.Step == 4) { await messageSession.CloseAsync(); } } catch (Exception ex) { log.LogError($"Message exception (Id={messageId} {ex.Message})"); } }
private static async Task HandleSessionMessage(IMessageSession session, Message message, CancellationToken cancellationToken) { if (message.Label != null && message.ContentType != null && message.Label.Equals("RecipeStep", StringComparison.InvariantCultureIgnoreCase) && message.ContentType.Equals("application/json", StringComparison.InvariantCultureIgnoreCase)) { var body = message.Body; dynamic recipeStep = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(body)); lock (Console.Out) { Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine( "Message received: SessionId = {0}, MessageId = {1}, SequenceNumber = {2}, Content: [ step = {3}, title = {4} ]", message.SessionId, message.MessageId, message.SystemProperties.SequenceNumber, recipeStep.step, recipeStep.title); Console.ResetColor(); } await session.CompleteAsync(message.SystemProperties.LockToken); if (recipeStep.step == 5) { // end of the session! await session.CloseAsync(); } } else { await session.DeadLetterAsync(message.SystemProperties.LockToken); } }
private static void ReceiveMessages(ISessionClient sessionClient) { IMessageSession messageSession = sessionClient.AcceptMessageSessionAsync("Test1").GetAwaiter().GetResult(); Program c = new Program(); try { Message messageReceived = null; do { log.Info("Receiver listening"); messageReceived = messageSession.ReceiveAsync().GetAwaiter().GetResult(); if (messageReceived != null) { Console.WriteLine($"Received message: SequenceNumber:{messageReceived.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(messageReceived.Body)}"); //this command permit to delete messages from the Cloud service, if the connection lost the application retry to download datas messageSession.CompleteAsync(messageReceived.SystemProperties.LockToken).GetAwaiter().GetResult(); } //call of method to move files from a directory to anothe c.ConfigurationSourceDestinationPath("sourcePath", "destinationPath", $"{Encoding.UTF8.GetString(messageReceived.Body)}"); } while (!messageSession.IsClosedOrClosing); Console.WriteLine("Press any key to exit"); Console.ReadKey(); } finally { messageSession.CloseAsync().GetAwaiter().GetResult(); Console.ReadKey(); } }
private async Task ReceiveResponse(string sessionId) { try { SessionClient sessionClient = new SessionClient(_connectionString, _queueServerName); IMessageSession messageSession = await sessionClient.AcceptMessageSessionAsync(sessionId); Message messagePayload = await messageSession.ReceiveAsync(); if (messagePayload != null) { string message = Encoding.UTF8.GetString(messagePayload.Body); ReplyListBox.Items.Add(ConstructMessageListBox(sessionId, message, false)); } else { ReplyListBox.Items.Add(ConstructMessageListBox(sessionId, "Failed getting response", false)); } await messageSession.CloseAsync(); await sessionClient.CloseAsync(); } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }
static async Task ProcessSessionMessagesAsync(IMessageSession session, Message message, CancellationToken token) { dynamic msg = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(message.Body)); lock (Console.Out) { Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine( "Message received: \n\tSessionId = {0}, \n\tMessageId = {1}, \n\tSequenceNumber = {2}," + "\n\tContent: [ Name = {3}, Step = {4} ]", message.SessionId, message.MessageId, message.SystemProperties.SequenceNumber, msg.name, msg.step); Console.ResetColor(); } await SendCompletionAsync(message.ReplyTo, message.ReplyToSessionId, msg); await session.CompleteAsync(message.SystemProperties.LockToken); if (msg.step == 5) { // end of the session! await session.CloseAsync(); Console.WriteLine("\n\t********** END OF SESSION *************"); } }
public async Task <List <Message> > ReceiveMessagesAsync() { var messages = new List <Message>(); IMessageSession session = await _sessionClient.AcceptMessageSessionAsync(_serviceBusContext.SessionId); if (session == null) { return(messages); } for (int i = 0; i < _serviceBusContext.MaxConcurrentMessagesToBeRetrieved; i++) { Message message = await session.ReceiveAsync(_serviceBusContext.OperationTimeout); if (message == null) { break; } messages.Add(message); await session.CompleteAsync(message.SystemProperties.LockToken); } await session.CloseAsync(); return(messages); }
private Task CloseSession(bool success, IMessageSession session, CancellationToken cancellationToken) { return(receiveRetryPolicy.ExecuteAsync( async() => { try { await session.CloseAsync(); if (success) { dynamicThrottling.NotifyWorkCompleted(); } else { dynamicThrottling.NotifyWorkCompletedWithError(); } return Task.CompletedTask; } catch (Exception ex) { logger.LogError($"An unrecoverable error occurred while trying to CLOSE a session in subscription \"{subscription}\":\r\n{ex.Message}"); dynamicThrottling.NotifyWorkCompletedWithError(); return Task.CompletedTask; } })); }
async Task OperationsOnMessageSessionAfterCloseShouldThrowObjectDisposedExceptionTest() { var sender = new MessageSender(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName); var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName); IMessageSession sessionReceiver = null; try { var messageId = "test-message1"; var sessionId = Guid.NewGuid().ToString(); await sender.SendAsync(new Message { MessageId = messageId, SessionId = sessionId }); TestUtility.Log($"Sent Message: {messageId} to Session: {sessionId}"); sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId); Assert.NotNull(sessionReceiver); TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}: LockedUntilUtc: {sessionReceiver.LockedUntilUtc}"); await sessionReceiver.CloseAsync(); await Assert.ThrowsAsync <ObjectDisposedException>(async() => await sessionReceiver.ReceiveAsync()); await Assert.ThrowsAsync <ObjectDisposedException>(async() => await sessionReceiver.GetStateAsync()); await Assert.ThrowsAsync <ObjectDisposedException>(async() => await sessionReceiver.SetStateAsync(null)); sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId); Assert.NotNull(sessionReceiver); TestUtility.Log($"Reaccept Session: SessionId: {sessionReceiver.SessionId}: LockedUntilUtc: {sessionReceiver.LockedUntilUtc}"); var message = await sessionReceiver.ReceiveAsync(); Assert.True(message.MessageId == messageId); TestUtility.Log($"Received Message: MessageId: {message.MessageId}"); await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken); await sessionReceiver.CloseAsync(); } finally { await sender.CloseAsync(); await sessionClient.CloseAsync(); } }
public async Task TransactionalSessionDispositionTest(string queueName) { var sender = new MessageSender(ConnectionString, queueName); var sessionClient = new SessionClient(ConnectionString, queueName); IMessageSession receiver = null; try { string body = Guid.NewGuid().ToString("N"); var message = new Message(body.GetBytes()) { SessionId = body }; await sender.SendAsync(message).ConfigureAwait(false); receiver = await sessionClient.AcceptMessageSessionAsync(body); var receivedMessage = await receiver.ReceiveAsync(ReceiveTimeout); Assert.NotNull(receivedMessage); Assert.Equal(body, receivedMessage.Body.GetString()); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken); ts.Dispose(); } // Adding delay since transaction Commit/Rollback is an asynchronous operation. // Operating on the same message should not be done. await Task.Delay(TimeSpan.FromSeconds(2)); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken); ts.Complete(); } // Adding delay since transaction Commit/Rollback is an asynchronous operation. // Operating on the same message should not be done. await Task.Delay(TimeSpan.FromSeconds(2)); await Assert.ThrowsAsync <SessionLockLostException>(async() => await receiver.CompleteAsync(receivedMessage.SystemProperties.LockToken)); } finally { await sender.CloseAsync(); await sessionClient.CloseAsync(); if (receiver != null) { await receiver.CloseAsync(); } } }
private static async Task Aselole(IMessageSession session, Message message, CancellationToken arg3) { if (message.Label != null && message.ContentType != null && //message.Label.Equals("RecipeStep", StringComparison.InvariantCultureIgnoreCase) && message.ContentType.Equals("application/json", StringComparison.InvariantCultureIgnoreCase)) { if (message.SessionId == null) { return; } if (isFirstMessage) { expectedNoMessages = (int)message.UserProperties["TotalMessages"]; messages = new Message[expectedNoMessages]; isFirstMessage = false; sessionId = message.SessionId; correlationId = message.CorrelationId; isFirstMessage = false; } var messageNo = (int)message.UserProperties["MessageNo"]; var messageIndex = messageNo - 1; Console.WriteLine(string.Format("Receiving message {0}", messageNo)); messages[messageIndex] = message; messagesReceived++; var body = message.Body; //string recipeStep = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(body)); lock (Console.Out) { Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine( "\t\t\t\tMessage received: \n\t\t\t\t\t\tSessionId = {0}, \n\t\t\t\t\t\tMessageId = {1}, \n\t\t\t\t\t\tSequenceNumber = {2}," + "\n\t\t\t\t\t\tContent: [ step = {3}, title = {4} ]", message.SessionId, message.MessageId, message.SystemProperties.SequenceNumber, "", ""); Console.ResetColor(); } await session.CompleteAsync(message.SystemProperties.LockToken); if (message.UserProperties["EOF"] != null) { await session.CloseAsync(); } } else { await session.DeadLetterAsync(message.SystemProperties.LockToken);//, "BadMessage", "Unexpected message"); } }
async Task <long> DoPurgeSessionEntity(long messagesToPurgeCount) { long totalMessagesPurged = 0; ISessionClient sessionClient = new SessionClient( serviceBusHelper.ConnectionString, GetEntityPath(deadLetterQueue: false), null, receiveMode: ReceiveMode.ReceiveAndDelete, retryPolicy: RetryPolicy.Default, prefetchCount: 10, transportType: serviceBusHelper.TransportType); var consecutiveSessionTimeOuts = 0; try { const int enoughZeroReceives = 3; while (consecutiveSessionTimeOuts < enoughZeroReceives && totalMessagesPurged < messagesToPurgeCount) { IMessageSession session = await sessionClient.AcceptMessageSessionAsync(); var consecutiveZeroBatchReceives = 0; while (consecutiveZeroBatchReceives < enoughZeroReceives && totalMessagesPurged < messagesToPurgeCount) { var messages = await session.ReceiveAsync(1000, TimeSpan.FromMilliseconds(1000)) .ConfigureAwait(false); if (messages != null && messages.Any()) { Interlocked.Add(ref totalMessagesPurged, messages.Count()); consecutiveZeroBatchReceives = 0; } else { ++consecutiveZeroBatchReceives; } } await session.CloseAsync().ConfigureAwait(false); } } catch (TimeoutException) { ++consecutiveSessionTimeOuts; } finally { await sessionClient.CloseAsync().ConfigureAwait(false); } return(totalMessagesPurged); }
public async Task <Dictionary <string, string> > CheckMessagesReceived(string subscriptionName, string tokenID) { List <Message> message = new List <Message>(); Dictionary <string, string> topicAndSubscriptionFound = new Dictionary <string, string>(); var topicsRegistered = await new ManageAzurePortal().CheckTopics(subscriptionName); if (topicsRegistered.Count > 0) { Action <object> delegateCheck = (topic) => { ISessionClient sessionClient = new SessionClient(appOptions.BusConnectionString, EntityNameHelper.FormatSubscriptionPath(topic.ToString(), subscriptionName), ReceiveMode.PeekLock); IMessageSession session = sessionClient.AcceptMessageSessionAsync(tokenID).GetAwaiter().GetResult(); if (session != null) { message = (List <Message>)session.ReceiveAsync(1, new TimeSpan(0, 0, 20)).GetAwaiter().GetResult(); if (message == null) { session.CloseAsync().GetAwaiter().GetResult(); sessionClient.CloseAsync().GetAwaiter().GetResult(); } else { topicAndSubscriptionFound.Add(topic.ToString(), subscriptionName); session.CloseAsync().GetAwaiter().GetResult(); sessionClient.CloseAsync().GetAwaiter().GetResult(); } } }; Task[] taskArray = new Task[topicsRegistered.Count]; for (int i = 0; i < taskArray.Length; i++) { taskArray[i] = Task.Factory.StartNew(delegateCheck, topicsRegistered[i]); } Task.WaitAll(taskArray); } return(topicAndSubscriptionFound); }
private static async Task <long> ProcessNextMessagesWithSessionStateAsync(SubscriptionClient client, IMessageSession session, SessionStateManager session_state, ConsoleColor color) { int x = session_state.LastProcessedCount + 1; long seq2 = 0; while (true) { if (!session_state.DeferredList.TryGetValue(x, out seq2)) { break; } //------------------------------- var deferredMessage = await session.ReceiveDeferredMessageAsync(seq2); if (ProcessMessages(deferredMessage, color)) { await session.CompleteAsync(deferredMessage.SystemProperties.LockToken); if (deferredMessage.UserProperties["IsLast"].ToString().ToLower() == "true") { //end of the session await session.SetStateAsync(null); await session.CloseAsync(); } else { session_state.LastProcessedCount = ((int)deferredMessage.UserProperties["Order"]); session_state.DeferredList.Remove(x); await session.SetStateAsync(Serialize <SessionStateManager>(session_state)); } } else { await client.DeadLetterAsync(deferredMessage.SystemProperties.LockToken, "Message is of the wrong type or could not be processed", "Cannot deserialize this message as the type is unknown."); session_state.DeferredList.Remove(x); await session.SetStateAsync(Serialize <SessionStateManager>(session_state)); } //------------------------------ x++; } return(seq2); }
async Task CloseSessionIfNeededAsync(IMessageSession session) { if (!session.IsClosedOrClosing) { try { await session.CloseAsync().ConfigureAwait(false); MessagingEventSource.Log.SessionReceivePumpSessionClosed(this.clientId, session.SessionId); } catch (Exception exception) { MessagingEventSource.Log.SessionReceivePumpSessionCloseException(this.clientId, session.SessionId, exception); await this.RaiseExceptionReceived(exception, ExceptionReceivedEventArgsAction.CloseMessageSession).ConfigureAwait(false); } } }
public List <Message> ReceiveMessages(Dictionary <string, string> topicAndSubscriptionReceived, string tokenID) { if (topicAndSubscriptionReceived.Count < 1) { return(null); } List <Message> listMessage = new List <Message>(); Action <object> delegateGetMessages = (topicSubscriptionMessage) => { var messageFound = (KeyValuePair <string, string>)topicSubscriptionMessage; ISessionClient sessionClient = new SessionClient(appOptions.BusConnectionString, EntityNameHelper.FormatSubscriptionPath(messageFound.Key, messageFound.Value), ReceiveMode.PeekLock); IMessageSession session = sessionClient.AcceptMessageSessionAsync(tokenID).GetAwaiter().GetResult(); while (true) { Message message = session.ReceiveAsync(new TimeSpan(0, 0, 20)).GetAwaiter().GetResult(); if (message == null) { session.CloseAsync().GetAwaiter().GetResult(); sessionClient.CloseAsync().GetAwaiter().GetResult(); break; } else { session.CompleteAsync(message.SystemProperties.LockToken).GetAwaiter().GetResult(); listMessage.Add(message); } } }; Task[] taskArray = new Task[topicAndSubscriptionReceived.Count]; List <KeyValuePair <string, string> > lstTopicAndSubscriptionReceived = new List <KeyValuePair <string, string> >(); foreach (KeyValuePair <string, string> topicAndSubscription in topicAndSubscriptionReceived) { lstTopicAndSubscriptionReceived.Add(topicAndSubscription); } for (int i = 0; i < taskArray.Length; i++) { taskArray[i] = Task.Factory.StartNew(delegateGetMessages, lstTopicAndSubscriptionReceived[i]); } Task.WaitAll(taskArray); return(listMessage); }
private async Task <SessionTrackerAction> TrackLastMessageTimeout(IDurableOrchestrationClient starter, IMessageSession messageSession, string messageId) { if (_sessionsTracker.TryGetValue(messageSession.SessionId, out var sessionTracker)) { if (sessionTracker.ReceivedLastMessage) { return(SessionTrackerAction.Continue); } if (messageId != sessionTracker.LatestMessageId) { return(SessionTrackerAction.Stop); } int.TryParse(_configuration["GraphUpdater:LastMessageWaitTimeout"], out int timeOut); timeOut = timeOut == 0 ? 10 : timeOut; var elapsedTime = DateTime.UtcNow - sessionTracker.LastAccessTime; if (elapsedTime.TotalMinutes >= timeOut) { _sessionsTracker.Remove(messageSession.SessionId, out _); await messageSession.CompleteAsync(sessionTracker.LockTokens); await messageSession.CloseAsync(); var cancelationRequest = new GraphUpdaterFunctionRequest { IsCancelationRequest = true, MessageSessionId = messageSession.SessionId, Message = JsonConvert.SerializeObject(new GroupMembership { SyncJobPartitionKey = sessionTracker.JobPartitionKey, SyncJobRowKey = sessionTracker.JobRowKey, RunId = sessionTracker.RunId }), }; await starter.StartNewAsync(nameof(OrchestratorFunction), cancelationRequest); return(SessionTrackerAction.Stop); } } return(SessionTrackerAction.Continue); }
public async Task <string> ExecuteRequestReplyOverSyncAsync(object content, bool waitForReply = true) { // Set/lock session string replySessionId = Guid.NewGuid().ToString(); IMessageSession session = await _replySessionClient.AcceptMessageSessionAsync(replySessionId); // lock session try { // Arrange payload string raw = JsonConvert.SerializeObject(content); var message = new Message { Body = Encoding.UTF8.GetBytes(raw), ReplyToSessionId = replySessionId // tell recipient to reply using this session ID }; // Send request using (new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled)) await _requestClient.SendAsync(message); // Exit early if you don't want to wait for reply if (waitForReply == false) { return($"Successfully sent request with sessionId: {replySessionId}"); } // Receive reply Message reply = await session.ReceiveAsync(TimeSpan.FromSeconds(10)); // 10s timeout if (reply == null) { return($"Failed to get reply within timeout for session {replySessionId}"); } string response = Encoding.UTF8.GetString(reply.Body); await session.CompleteAsync(reply.SystemProperties.LockToken); return(response); } finally { await session.CloseAsync(); // release exlusive lock } }
public async Task AcceptSessionThrowsSessionCannotBeLockedException() { var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName); var someSessionId = "someSessionId"; IMessageSession session = null; try { session = await sessionClient.AcceptMessageSessionAsync(someSessionId); await Assert.ThrowsAsync <SessionCannotBeLockedException>(async() => session = await sessionClient.AcceptMessageSessionAsync(someSessionId)); } finally { await sessionClient.CloseAsync().ConfigureAwait(false); await session?.CloseAsync(); } }
public async Task <string> GetResponseServiceBus() { var sessionClient = new SessionClient(_connectionStrings.ServiceBus, _responseQueueName); IMessageSession session = await sessionClient.AcceptMessageSessionAsync(HttpContext.Session.Id); if (session != null) { Message message = await session.ReceiveAsync(); if (message != null) { await session.CompleteAsync(message.SystemProperties.LockToken); return(Encoding.UTF8.GetString(message.Body)); } await session.CloseAsync(); } return(string.Empty); }
protected override void HandleListenForClientMessagesChanged(bool value) { lock (_listenForClientSessionMessagesToken) { if (value) { _clientSessionListenCancellationToken = new CancellationTokenSource(); Logger.Debug("Listening for client messages"); _clientSessionListenTask = StartListeningForClientMessages(_clientSessionListenCancellationToken.Token); } else if (_activeClientSession != null) { Logger.Debug("Stopped listening for client messages"); _clientSessionListenCancellationToken.Cancel(); _clientSessionListenTask.Wait(); _clientSessionListenTask = null; _activeClientSession.CloseAsync().Wait(); } } }
public async Task HandleNewMessage(GroupMembershipMessage body, IMessageSession messageSession) { var sessionId = messageSession.SessionId; _receivedMessages.AddOrUpdate(sessionId, new List <GroupMembershipMessage> { body }, (key, messages) => { messages.Add(body); return(messages); }); //Console.WriteLine($"Session {sessionId} got {body.Body.SourceMembers.Count} users."); if (body.Body.IsLastMessage) { if (!_receivedMessages.TryRemove(sessionId, out var allReceivedMessages)) { // someone else got to it first. shouldn't happen, but it's good to be prepared. return; } // remove this message-renewing logic once we can verify that the new, longer message leases work. var source = new CancellationTokenSource(); var cancellationToken = source.Token; var renew = RenewMessages(messageSession, allReceivedMessages, cancellationToken); var received = GroupMembership.Merge(allReceivedMessages.Select(x => x.Body)); try { await _graphUpdater.CalculateDifference(received); // If it succeeded, complete all the messages and close the session await messageSession.CompleteAsync(allReceivedMessages.Select(x => x.LockToken)); await messageSession.CloseAsync(); } finally { source.Cancel(); } } }
public static async Task Run([ServiceBusTrigger("load-test", Connection = "LoadQueueConnectionString", IsSessionsEnabled = true)] Message message, IMessageSession messageSession, ILogger log) { log.LogInformation($"MessageReceived: {message.MessageId}"); //Force assembly to be in memory for this example - can be fixed with DI I think var _ = typeof(IntermediateModelRepository); var messages = new List <Message> { message }; var entityName = (string)message.UserProperties["EntityName"]; var taskId = (Guid)message.UserProperties["TaskId"]; var isLast = (bool)message.UserProperties["Last"]; await messageSession.CompleteAsync(message.SystemProperties.LockToken); //Get the model type var model = AppDomain.CurrentDomain .GetAssemblies() .FirstOrDefault(assembly => assembly.GetName().Name == "Kalibrate.DTM.DataMapper.Shared") ?.GetTypes() .FirstOrDefault(type => type.Name == entityName); //Keep receiving new messages in the session until the last message is received. while (!isLast) { message = await messageSession.ReceiveAsync(); messages.Add(message); log.LogInformation($"MessageReceived: {message.MessageId} "); isLast = (bool)message.UserProperties["Last"]; await messageSession.CompleteAsync(message.SystemProperties.LockToken); } log.LogInformation($"Messages - Task:{taskId}, Messages:{messages.Count}"); //All messages in the session have been received, now process them ProcessMessages(messages, model, taskId, messageSession, log); //All messages have been processed and closed, so we can now close the session await messageSession.CloseAsync(); }
public async Task AcceptSessionThrowsSessionCannotBeLockedException() { await ServiceBusScope.UsingQueueAsync(partitioned : true, sessionEnabled : true, async queueName => { var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName); var someSessionId = "someSessionId"; IMessageSession session = null; try { session = await sessionClient.AcceptMessageSessionAsync(someSessionId); await Assert.ThrowsAsync <SessionCannotBeLockedException>(async() => session = await sessionClient.AcceptMessageSessionAsync(someSessionId)); } finally { await sessionClient.CloseAsync(); await session?.CloseAsync(); } }); }
static async Task ReceiveSessionMessagesAsync(int numberOfSessions, int messagesPerSession) { Console.WriteLine("==================================================================="); Console.WriteLine("Accepting sessions in the reverse order of sends for demo purposes"); Console.WriteLine("==================================================================="); for (int i = 0; i < numberOfSessions; i++) { int messagesReceivedPerSession = 0; // AcceptMessageSessionAsync(i.ToString()) as below with session id as parameter will try to get a session with that sessionId. // AcceptMessageSessionAsync() without any messages will try to get any available session with messages associated with that session. IMessageSession session = await sessionClient.AcceptMessageSessionAsync("2c812750-f89e-4e1e-b8bc-a104bd8dde16"); if (session != null) { // Messages within a session will always arrive in order. Console.WriteLine("====================================="); Console.WriteLine($"Received Session: {session.SessionId}"); while (messagesReceivedPerSession++ < messagesPerSession) { Message message = await session.ReceiveAsync(); //Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}"); Console.WriteLine($"Message {message.UserProperties["MessageNo"].ToString()} of {message.UserProperties["TotalMessages"].ToString()} received"); // Complete the message so that it is not received again. // This can be done only if the queueClient is created in ReceiveMode.PeekLock mode (which is default). await session.CompleteAsync(message.SystemProperties.LockToken); } Console.WriteLine($"Received all messages for Session: {session.SessionId}"); Console.WriteLine("====================================="); // Close the Session after receiving all messages from the session await session.CloseAsync(); } } }
static async Task ReceiveMessage(string sessionId) { try { SessionClient sessionClient = new SessionClient(_connectionString, _queueServerName); IMessageSession messageSession = await sessionClient.AcceptMessageSessionAsync(sessionId); Message message = await messageSession.ReceiveAsync(); if (message != null) { string messageText = Encoding.UTF8.GetString(message.Body); Console.WriteLine($"[{DateTime.Now}] Reply from server: {messageText}"); } await messageSession.CloseAsync(); await sessionClient.CloseAsync(); } catch (Exception ex) { Console.WriteLine($"[x] Error: {ex.Message}"); } }
private static async Task ClenaUpEntity(string connectionString, string entityPAth) { var client = new SessionClient(connectionString, entityPAth, ReceiveMode.PeekLock); client.OperationTimeout = TimeSpan.FromSeconds(5); IMessageSession session = null; try { session = await client.AcceptMessageSessionAsync(); while (true) { var message = await session.ReceiveAsync(TimeSpan.FromSeconds(5)); if (message != null) { await session.CompleteAsync(message.SystemProperties.LockToken); } else { break; } } } catch (ServiceBusException) { } finally { if (session != null) { await session.CloseAsync(); } } }
public async Task RunAsync( [ServiceBusTrigger("%membershipQueueName%", Connection = "differenceQueueConnection", IsSessionsEnabled = true)] Message message, [DurableClient] IDurableOrchestrationClient starter, IMessageSession messageSession) { await _loggingRepository.LogMessageAsync(new LogMessage { Message = nameof(StarterFunction) + " function started" }); var messageDetails = _messageService.GetMessageProperties(message); var graphRequest = new GraphUpdaterFunctionRequest() { Message = Encoding.UTF8.GetString(messageDetails.Body), MessageSessionId = messageDetails.SessionId, MessageLockToken = messageDetails.LockToken }; var groupMembership = JsonConvert.DeserializeObject <GroupMembership>(graphRequest.Message); SetSessionTracker(messageDetails, groupMembership); var source = new CancellationTokenSource(); var renew = RenewMessages(starter, messageSession, source, messageDetails.MessageId); var instanceId = await starter.StartNewAsync(nameof(OrchestratorFunction), graphRequest); var completedGroupMembershipMessages = default(List <GroupMembershipMessage>); var isLastMessage = false; var orchestratorRuntimeStatusCodesWorthRetrying = new OrchestrationRuntimeStatus[] { OrchestrationRuntimeStatus.ContinuedAsNew, OrchestrationRuntimeStatus.Running, OrchestrationRuntimeStatus.Pending }; var result = default(DurableOrchestrationStatus); /*Understanding the Retry policy * We have a lot of sub-second sync execution so the first query would ensure we cater to those queries * We also have a lot of syncs that take less than 10 seconds. Having a exponetial backoff 1.25^1 would mean we would be waiting 90 seconds per sync instead of 10 seconds. * Hence the logic to ensure retryAttempt 1 is done after 10 seconds. Following this we go back to the exponetial backoff. */ var retryPolicy = Policy .HandleResult <DurableOrchestrationStatus>(status => orchestratorRuntimeStatusCodesWorthRetrying.Contains(status.RuntimeStatus)) .WaitAndRetryAsync( MAX_RETRY_ATTEMPTS, retryAttempt => { if (retryAttempt == 1) { return(TimeSpan.FromSeconds(FIRST_RETRY_DELAY_IN_SECONDS)); } else { return(TimeSpan.FromMinutes(Math.Pow(1.25, retryAttempt - 1))); } } ); await retryPolicy.ExecuteAsync(async() => { result = await starter.GetStatusAsync(instanceId); return(result); }); if (result.RuntimeStatus == OrchestrationRuntimeStatus.Failed || result.RuntimeStatus == OrchestrationRuntimeStatus.Terminated) { await _loggingRepository.LogMessageAsync(new LogMessage { Message = $"Error: Status of instance {result.InstanceId} is {result.RuntimeStatus}. The error message is : {result.Output}" }); // stop renewing the message session source.Cancel(); } else { await _loggingRepository.LogMessageAsync(new LogMessage { Message = $"Instance processing completed for {result.InstanceId}" }); var orchestratorResponseOutput = JsonConvert.DeserializeObject <GroupMembershipMessageResponse>(result.Output.ToString()); completedGroupMembershipMessages = orchestratorResponseOutput.CompletedGroupMembershipMessages; isLastMessage = orchestratorResponseOutput.ShouldCompleteMessage; } if (isLastMessage) { var completedLockTokens = completedGroupMembershipMessages.Select(x => x.LockToken); await messageSession.CompleteAsync(completedLockTokens); await messageSession.CloseAsync(); source.Cancel(); } await _loggingRepository.LogMessageAsync(new LogMessage { Message = nameof(StarterFunction) + " function completed" }); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ExecutionContext context, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); var connectionString = "Endpoint=sb://ccaidauesdevir2sb001.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=OLQnsp0G3L2TtD9WfNUTWZ0TdJ9lnpuFggJV2R6Vc/A="; string queueName = req.Query["queueName"]; var policy = new RetryExponential( minimumBackoff: TimeSpan.FromSeconds(10), maximumBackoff: TimeSpan.FromSeconds(30), maximumRetryCount: 3); ISessionClient client = new SessionClient(connectionString, queueName, ReceiveMode.PeekLock, policy); log.LogInformation("Waiting for new message"); string sessionIdParam = req.Query["sessionId"]; #region variables IMessageSession messageSession = await client.AcceptMessageSessionAsync(sessionIdParam); var keepPolling = true; var isFirstMessage = true; var expectedNoMessages = 0; Message[] messages = null; var messagesReceived = 0; var sessionId = string.Empty; var correlationId = string.Empty; Stream fullMessageBodyStream = null; #endregion while (keepPolling) { var message = await messageSession.ReceiveAsync(); if (message == null) { continue; } if (isFirstMessage) { log.LogInformation("Receiving first message"); expectedNoMessages = (int)message.UserProperties["TotalMessages"]; messages = new Message[expectedNoMessages]; isFirstMessage = false; sessionId = message.SessionId; correlationId = message.CorrelationId; } var messageNo = (int)message.UserProperties["MessageNo"]; var messageIndex = messageNo - 1; log.LogInformation(string.Format("Receiving message {0}", messageNo)); messages[messageIndex] = message; messagesReceived++; if (messagesReceived == expectedNoMessages) { keepPolling = false; } } //Rebuild Object fullMessageBodyStream = ReconstructMessageBody(messages); var result = ReadStreamData(fullMessageBodyStream); log.LogInformation($"SessionId = {sessionId}."); log.LogInformation($"result = {result}."); var completeTasks = new List <Task>(); var lockToken = new List <string>(); foreach (var message in messages) { lockToken.Add(message.SystemProperties.LockToken); //await messageSession.CompleteAsync(message.SystemProperties.LockToken); } completeTasks.Add(messageSession.CompleteAsync(lockToken)); Task.WaitAll(completeTasks.ToArray()); await messageSession.CloseAsync(); return(new OkObjectResult("Ok")); }