async Task ProcessMessagesAsync(IMessageSession messageSession, Message message, CancellationToken token) { try { var student = JsonConvert.DeserializeObject <Student>(Encoding.UTF8.GetString(message.Body)); lock (thisLock) { //revalidation if course is available. if (_signupRepo.CourseIsAvailable(student.CourseId)) { _signupRepo.SigningupCourse(student); //TODO: Send Email } else { //TODO: SEND EMAIL THAT COURSE IS NOT AVAILABLE. } } await messageSession.CompleteAsync(message.SystemProperties.LockToken); } catch (SessionLockLostException) { await messageSession.RenewSessionLockAsync(); await messageSession.CompleteAsync(message.SystemProperties.LockToken); } }
private async Task RenewMessages(IMessageSession messageSession, List <GroupMembershipMessage> messages, CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { await messageSession.RenewSessionLockAsync(); foreach (var message in messages) { await messageSession.RenewLockAsync(message.LockToken); } await Task.Delay(_waitBetweenRenew); } }
async Task RenewSessionLockTaskAsync(IMessageSession session, CancellationToken renewLockCancellationToken) { while (!this.pumpCancellationToken.IsCancellationRequested && !renewLockCancellationToken.IsCancellationRequested) { try { var amount = MessagingUtilities.CalculateRenewAfterDuration(session.LockedUntilUtc); MessagingEventSource.Log.SessionReceivePumpSessionRenewLockStart(this.clientId, session.SessionId, amount); await Task.Delay(amount, renewLockCancellationToken).ConfigureAwait(false); if (!this.pumpCancellationToken.IsCancellationRequested && !renewLockCancellationToken.IsCancellationRequested) { await session.RenewSessionLockAsync().ConfigureAwait(false); MessagingEventSource.Log.SessionReceivePumpSessionRenewLockStop(this.clientId, session.SessionId); } else { break; } } catch (Exception exception) { MessagingEventSource.Log.SessionReceivePumpSessionRenewLockException(this.clientId, session.SessionId, exception); // TaskCanceled is expected here as renewTasks will be cancelled after the Complete call is made. // ObjectDisposedException should only happen here because the CancellationToken was disposed at which point // this renew exception is not relevant anymore. Lets not bother user with this exception. if (!(exception is TaskCanceledException) && !(exception is ObjectDisposedException)) { await this.RaiseExceptionReceived(exception, ExceptionReceivedEventArgsAction.RenewLock).ConfigureAwait(false); } if (!MessagingUtilities.ShouldRetry(exception)) { break; } } } }
private async Task RenewMessages( IDurableOrchestrationClient starter, IMessageSession messageSession, CancellationTokenSource cancellationToken, string messageId) { while (!cancellationToken.IsCancellationRequested) { var action = await TrackLastMessageTimeout(starter, messageSession, messageId); if (action == SessionTrackerAction.Stop) { break; } await messageSession.RenewSessionLockAsync(); await Task.Delay(_waitBetweenRenew); } }
async Task RenewSessionLockTaskAsync(IMessageSession session, CancellationToken renewLockCancellationToken) { while (!this.pumpCancellationToken.IsCancellationRequested && !renewLockCancellationToken.IsCancellationRequested) { try { TimeSpan amount = MessagingUtilities.CalculateRenewAfterDuration(session.LockedUntilUtc); MessagingEventSource.Log.SessionReceivePumpSessionRenewLockStart(this.clientId, session.SessionId, amount); await Task.Delay(amount, renewLockCancellationToken).ConfigureAwait(false); if (!this.pumpCancellationToken.IsCancellationRequested && !renewLockCancellationToken.IsCancellationRequested) { await session.RenewSessionLockAsync().ConfigureAwait(false); MessagingEventSource.Log.SessionReceivePumpSessionRenewLockStop(this.clientId, session.SessionId); } else { break; } } catch (Exception exception) { MessagingEventSource.Log.SessionReceivePumpSessionRenewLockExeption(this.clientId, session.SessionId, exception); // TaskCancelled is expected here as renewTasks will be cancelled after the Complete call is made. // Lets not bother user with this exception. if (!(exception is TaskCanceledException)) { this.sessionHandlerOptions.RaiseExceptionReceived(new ExceptionReceivedEventArgs(exception, "RenewLock")); } if (!MessagingUtilities.ShouldRetry(exception)) { break; } } } }
private async Task ReaquireClientSessionLock() { var waitTime = TimeSpan.FromSeconds(0.5); while (true) { try { await _activeClientSession.RenewSessionLockAsync(); Logger.Info("Successfully aquired lock"); break; } catch (Exception renewException) { // Sometimes necessary when there are connection issues Logger.Warn($"Encountered error while re-aquiring session lock ({renewException.Message}), will create new session lock"); try { _activeClientSession = await ClientSessionListener.Value.AcceptMessageSessionAsync(State[ApolloConstants.RegisteredAsKey].ToString(), TimeSpan.FromMinutes(30)); Logger.Info("Successfully created a new session lock"); break; } catch (ServiceBusCommunicationException ex) { Logger.Debug(ex.Message); Logger.Info("Connection to service bus lost, waiting for it to re-establish"); while (true) { try { var entry = await Dns.GetHostEntryAsync(Configuration.ConnectionStringBuilder.Endpoint.Replace("sb://", string.Empty)); if (entry != null) { Logger.Info($"Managed to resolve service bus endpoint to {entry.HostName}, will now retry"); break; } } catch { // Suppress } await Task.Delay(300, _clientSessionListenCancellationToken.Token); } Configuration.Reconnect(); await Impl.Recreate(); continue; } catch (Exception recreateException) { Logger.Warn($"Encountered error while creating new session lock, will wait and try again in {waitTime.TotalSeconds} seconds"); Logger.Debug(recreateException); } await Task.Delay(waitTime, _clientSessionListenCancellationToken.Token); if (_clientSessionListenCancellationToken.Token.IsCancellationRequested) { break; } waitTime = TimeSpan.FromMilliseconds(Math.Min(waitTime.TotalMilliseconds * 1.5, TimeSpan.FromMinutes(1).TotalMilliseconds)); } } }