private async Task handleMessage(IMessageSession session, Message message, CancellationToken token) { var lockToken = message.SystemProperties.LockToken; Envelope envelope; try { envelope = _protocol.ReadEnvelope(message); } catch (Exception e) { _logger.LogException(e, message: "Error trying to map an incoming Azure Service Bus message to an Envelope. See the Dead Letter Queue"); await session.DeadLetterAsync(lockToken, "Bad Envelope", e.ToString()); return; } try { await _callback.Received(Address, new[] { envelope }); await session.CompleteAsync(lockToken); } catch (Exception e) { _logger.LogException(e, envelope.Id, "Error trying to receive a message from " + Address); await session.AbandonAsync(lockToken); } }
private static async Task processSessionMessagesAsync( IMessageSession session, Message message, CancellationToken cancelToken) { string body = Encoding.UTF8.GetString(message.Body); //string consoleMessage = $"Received Session: '{session.SessionId}' | SequenceNumber: {message.SystemProperties.SequenceNumber} | Body: '{body}'."; if (_random.NextDouble() <= 0.05) { await session.AbandonAsync(message.SystemProperties.LockToken); //Console.WriteLine("Abandon - " + consoleMessage); } else { await session.CompleteAsync(message.SystemProperties.LockToken); //Console.WriteLine(consoleMessage); await _rediDB.ListRightPushAsync(message.SessionId, body); // Check values: LRANGE Line-1 0 -1 _countdownEvent.Signal(); } }
private async Task ProcessSessionMessageAsync(IReceiverClient client, IMessageSession session, Message message, CancellationToken cancellationToken) { _logger.LogInformation("Type : {ClientType}", client.GetType()); try { _logger.LogInformation($"Session :{session.SessionId}"); _logger.LogInformation($"SequenceNumber:{message.SystemProperties.SequenceNumber}"); _logger.LogInformation($"Label :{message.Label}"); _logger.LogInformation($"DeliveryCount :{message.SystemProperties.DeliveryCount}"); string body = Encoding.UTF8.GetString(message.Body); if (body == "1") { await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); // simulate delay _logger.LogError("Error: " + DateTime.UtcNow); throw new Exception("!!!"); } //if (message.Label == nameof(PersonMessage)) //{ // var person = _serializer.Deserialize<PersonMessage>(message.Body); // _logger.LogInformation("person = " + JsonConvert.SerializeObject(person)); //} //else //{ // _logger.LogInformation("other = " + body); //} _logger.LogInformation("OK : " + body); await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken); // simulate delay await session.CompleteAsync(message.SystemProperties.LockToken); //await client.CompleteAsync(message.SystemProperties.LockToken); } catch (Exception ex) { _logger.LogError(ex, "Error while Process Message with MessageId: {MessageId}", message.MessageId); if (!session.IsClosedOrClosing) { var properties = new Dictionary <string, object> { { "uhuh", DateTime.UtcNow.ToString() } }; await session.AbandonAsync(message.SystemProperties.LockToken, properties); //await client.AbandonAsync(message.SystemProperties.LockToken); } } }
async Task AbandonMessageIfNeededAsync(IMessageSession session, Message message) { try { if (session.ReceiveMode == ReceiveMode.PeekLock) { await session.AbandonAsync(message.SystemProperties.LockToken).ConfigureAwait(false); } } catch (Exception exception) { await this.RaiseExceptionReceived(exception, ExceptionReceivedEventArgsAction.Abandon).ConfigureAwait(false); } }
private async Task ProcessMessageAsync(IReceiverClient client, IMessageSession session, Message message, CancellationToken cancellationToken) { _logger.LogInformation("Type : {ClientType}", client.GetType()); try { _logger.LogInformation("SystemProperties:{SystemProperties}", JsonConvert.SerializeObject(message.SystemProperties, Formatting.Indented)); _logger.LogInformation("IMessageSession :{IMessageSession}", JsonConvert.SerializeObject(session, Formatting.Indented)); string body = Encoding.UTF8.GetString(message.Body); if (body == "1") { await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); // simulate delay _logger.LogError("Error: " + DateTime.UtcNow); throw new Exception("!!!"); } if (message.Label == nameof(PersonMessage)) { var person = _serializer.Deserialize <PersonMessage>(message.Body); _logger.LogInformation("person = " + JsonConvert.SerializeObject(person)); } else { _logger.LogInformation("body = {body}", body); } await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken); // simulate delay await session.CompleteAsync(message.SystemProperties.LockToken); } catch (Exception ex) { _logger.LogError(ex, "Error while Process Message with MessageId: {MessageId}", message.MessageId); if (!session.IsClosedOrClosing) { await session.AbandonAsync(message.SystemProperties.LockToken); } } }
public Task Abandon(Exception exception) { return(_session.AbandonAsync(_message.SystemProperties.LockToken, ExceptionUtil.GetExceptionHeaderDictionary(exception))); }
private async Task RunDispatcherForSession(IMessageSession session, CancellationToken cancelToken) { while (cancelToken.IsCancellationRequested == false) { var msg = await session.ReceiveAsync(TimeSpan.FromSeconds(1)); if (msg != null) { bool isPersistedAfterCalculus = false; try { ActorBase actor = null; Type tp = Type.GetType((string)msg.UserProperties[ActorReference.cActorType]); if (tp == null) { throw new ArgumentException($"Cannot find type '{session.SessionId}'"); } var id = new ActorId((string)msg.UserProperties[ActorReference.cActorId]); if (!actorMap.ContainsKey(session.SessionId)) { if (this.persistenceProvider != null) { actor = await this.persistenceProvider.LoadActor(id); if (actor != null) { logger?.LogInformation($"{this.Name} - Loaded from pesisted store: {tp.Name}/{id}, actorMap: {actorMap.Keys.Count}"); } } if (actor == null) { actor = Activator.CreateInstance(tp, id) as ActorBase; logger?.LogInformation($"{this.Name} - New instance created: {tp.Name}/{id}, actorMap: {actorMap.Keys.Count}"); } actor.PersistenceProvider = this.PersistenceProvider; actor.Logger = logger; actorMap[session.SessionId] = actor; actor.Activated(); } actor = actorMap[session.SessionId]; logger?.LogInformation($"{this.Name} - Received message: {tp.Name}/{id}, actorMap: {actorMap.Keys.Count}"); var invokingMsg = ActorReference.DeserializeMsg <object>(msg.Body); var replyMsg = await InvokeOperationOnActorAsync(actor, invokingMsg, (bool)msg.UserProperties[ActorReference.cExpectResponse], msg.MessageId, msg.ReplyTo); logger?.LogInformation($"{this.Name} - Invoked : {tp.Name}/{id}, actorMap: {actorMap.Keys.Count}"); await persistAndCleanupIfRequired(session); logger?.LogInformation($"{this.Name} - Persisted : {tp.Name}/{id}, actorMap: {actorMap.Keys.Count}"); isPersistedAfterCalculus = true; // If actor operation was invoked with Ask<>(), then reply is expected. if (replyMsg != null) { await this.sendReplyQueueClients[msg.ReplyTo].SendAsync(replyMsg); logger?.LogInformation($"{this.Name} - Replied : {tp.Name}/{id}, actorMap: {actorMap.Keys.Count}"); } await session.CompleteAsync(msg.SystemProperties.LockToken); logger?.LogInformation($"{this.Name} - Completed : {tp.Name}/{id}, actorMap: {actorMap.Keys.Count}"); } catch (Exception ex) { logger.LogWarning(ex, "Messsage processing error"); if (isPersistedAfterCalculus == false) { await persistAndCleanupIfRequired(session); } if (!(ex is SessionLockLostException)) { await session.AbandonAsync(msg.SystemProperties.LockToken); } } } else { logger?.LogTrace($"{this.Name} - No more messages received for sesson {session.SessionId}"); await persistAndCleanupIfRequired(session); //return; } if (IsMemoryCritical()) { logger?.LogWarning($"Memory reached critical value: {this.CriticalMemInGb}, {Environment.WorkingSet / 1024 / 1024 / 1024}"); } break; } }