public async Task Run(
[ServiceBusTrigger("%ServiceBusConfig:WriteTopic%", "%ServiceBusConfig:CreateProductSubscription%", Connection = "ServiceBusConfig:ReadConnectionString", IsSessionsEnabled = true)]
Message message,
IMessageSession messageSession, string lockToken)
{
var operation = await _messageReader.GetModelAsync <CreateProductServiceBusMessage>(message);
if (!operation.Status)
{
await messageSession.DeadLetterAsync(lockToken, operation.ErrorCode);
return;
}
var model = operation.Data;
var insertProductCommand = new InsertProductCommand(model.CorrelationId, model.ProductCode, model.ProductName);
var insertOperation = await _mediator.Send(insertProductCommand);
if (!insertOperation.Status)
{
await messageSession.DeadLetterAsync(lockToken, insertOperation.ErrorCode);
return;
}
await messageSession.CompleteAsync(lockToken);
}
/// <inheritdoc/>
public async Task <SessionWorkflowState> ProcessSessionMessageAsync(IMessageSession session, Message message)
{
var state = await _stateManager.GetWorkflowStateAsync(session);
if (message.UserProperties.TryGetValue("ResetWorkflowState", out var shouldReset) && Convert.ToBoolean(shouldReset))
{
_logger.LogInformation($"[{nameof(ContractEventSessionManager)}.{nameof(ProcessSessionMessageAsync)}] - Reset workflow state message [{message.MessageId}] received, resetting session [{session.SessionId}].");
return(await _stateManager.ResetWorkflowStateAsync(session));
}
if (state.IsFaulted && state.FailedMessageId != message.MessageId)
{
_logger.LogWarning($"[{nameof(ContractEventSessionManager)}.{nameof(ProcessSessionMessageAsync)}] - Moving this message [{message.MessageId}] to DLQ, beacause previous message [{state.FailedMessageId}] failed, hence dropping all messages in session [{session.SessionId}].");
state.PostponedMessages.Add(message.MessageId);
await session.DeadLetterAsync(message.SystemProperties.LockToken, $"Previous message failed, hence dropping all messages in session", $"Previous message {state.FailedMessageId} failed, hence dropping all messages in session {session.SessionId}");
await _stateManager.SetWorkflowStateAsync(session, state);
}
else
{
if (state.IsFaulted && state.FailedMessageId == message.MessageId)
{
state = await _stateManager.ResetWorkflowStateAsync(session);
}
try
{
var contractEvent = JsonConvert.DeserializeObject <ContractEvent>(Encoding.UTF8.GetString(message.Body));
_processLog.Initialise(message, contractEvent);
await _contractService.ProcessMessage(contractEvent);
}
catch (NotImplementedException notImplemented)
{
await SaveFailedState(session, message, state, notImplemented, "Message contains not implemented input");
await session.DeadLetterAsync(message.SystemProperties.LockToken, $"Message contains not imeplemented input", $"Invalid message {state.FailedMessageId} in session {session.SessionId} reason - {notImplemented.Message}.");
}
catch (ContractEventExpectationFailedException badMessage)
{
await SaveFailedState(session, message, state, badMessage, "Message contains invalid input");
await session.DeadLetterAsync(message.SystemProperties.LockToken, $"Message contains invalid input", $"Invalid message {state.FailedMessageId} in session {session.SessionId} reason - {badMessage.Message}.");
}
catch (Exception ex)
{
if (message.SystemProperties.DeliveryCount >= _functionSettings.MaximumDeliveryCount)
{
await SaveFailedState(session, message, state, ex, "Message delivery count exceeded");
}
throw;
}
}
return(state);
}
public async Task DeadLetter()
{
var headers = new Dictionary <string, object> {
{ MessageHeaders.Reason, "dead-letter" }
};
await _session.DeadLetterAsync(_message.SystemProperties.LockToken, headers).ConfigureAwait(false);
_deadLettered = true;
}
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 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 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");
}
}
