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