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;
}
}
