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 ReceiveSessionMessagesAsync()
{
Console.WriteLine("===================================================================");
Console.WriteLine("Accepting sessions in the reverse order of sends for demo purposes");
Console.WriteLine("===================================================================");
var configuration = new AzureStorageAttachmentConfiguration(StorageConnectionString, containerName: "ovp");
sessionClient.RegisterAzureStorageAttachmentPlugin(configuration);
// 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();
if (session != null)
{
Message message = await session.ReceiveAsync();
var stream = new MemoryStream(message.Body);
StreamReader reader = new StreamReader(stream);
string text = reader.ReadToEnd();
Console.WriteLine($"message body : {text}");
await session.CompleteAsync(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();
}
}
public async Task <ActionResult <IEnumerable <string> > > Get()
{
var log = new List <string>();
var sessionId = Guid.NewGuid().ToString();
log.Add($"Creating session {sessionId}");
IMessageSession session = await _sessionClient.AcceptMessageSessionAsync(sessionId);
Message response = null;
var t = session.ReceiveAsync(new TimeSpan(0, 5, 0))
.ContinueWith(m => response = m.Result)
.ContinueWith(m => log.Add($"received response from service for {sessionId}"));
var message = new Message(Encoding.UTF8.GetBytes("test message"))
{
SessionId = sessionId
};
await _messageSender.SendAsync(message);
log.Add($"Sent work request for {sessionId}");
await t;
await session.CompleteAsync(response.SystemProperties.LockToken);
log.Add($"Completed session: {sessionId}");
return(log);
}
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);
}
}
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);
}
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 async Task OnMessage(IMessageSession session, Message messageToHandle, CancellationToken lockToken)
{
try {
session.PrefetchCount = 500;
IList <Message> batchList;
List <Message> fullList = new List <Message> {
messageToHandle
};
batchList = await session.ReceiveAsync(500);
if (!(batchList is null) && batchList.Count > 0)
{
fullList.AddRange(batchList);
}
foreach (Message msg in fullList)
{
if (!MessagesListedBySession.ContainsKey(session.SessionId))
{
_sessionsInitializedCount++;
MessagesListedBySession.TryAdd(session.SessionId, new List <string>());
}
string dataJSON = Encoding.UTF8.GetString(msg.Body);
MessagesListedBySession[session.SessionId].Add(dataJSON);
ProcessMessage(session, msg, dataJSON);
if (msg.Label.Equals("last", StringComparison.InvariantCultureIgnoreCase))
{
try {
ProcessMessagesWhenLastReceived(session, MessagesListedBySession[session.SessionId], msg);
} catch (Exception ex) {
if (!(logger is null))
{
logger.LogError(ex.Message);
logger.LogDebug(ex.StackTrace);
}
} finally {
MessagesListedBySession.Remove(session.SessionId);
}
}
}
//await sLock.WaitAsync();
//await session.CompleteAsync(fullList.Select(m => m.SystemProperties.LockToken)).ContinueWith((t) => sLock.Release());
await session.CompleteAsync(fullList.Select(m => m.SystemProperties.LockToken));
} catch (Exception ex) {
if (!(logger is null))
{
logger.LogError(ex.Message);
logger.LogDebug(ex.StackTrace);
}
//throw new ApplicationException(ex.Message + ex.StackTrace);
}
}
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 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);
}
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 <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);
}
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();
}
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();
}
}
}
private async Task StartListeningForClientMessages(CancellationToken cancelToken)
{
_activeClientSession = await ClientSessionListener.Value.AcceptMessageSessionAsync(State[ApolloConstants.RegisteredAsKey].ToString(), TimeSpan.FromMinutes(30));
while (_activeClientSession != null && _clientSessionListenCancellationToken != null && !_clientSessionListenCancellationToken.Token.IsCancellationRequested)
{
try
{
var messages = await _activeClientSession.ReceiveAsync(ClientMessagesPerReceive);
if (messages == null)
{
continue;
}
foreach (var message in messages)
{
await InvokeMessageHandlers(_activeClientSession, ApolloQueue.ClientSessions, new ServiceBusMessage(message), cancelToken);
}
}
catch (SessionLockLostException)
{
Logger.Info("Renewing session lock");
if (_activeClientSession == null)
{
throw;
}
await ReaquireClientSessionLock();
}
catch (ServiceBusTimeoutException ex)
{
Logger.Warn($"Timed out while trying to get session lock ({ex.Message}). Will retry");
Logger.Debug(ex);
// Timed out reconnecting, just try again
}
catch (Exception ex)
{
Logger.Error("Encountered an exception while trying to receive client session messages", ex);
}
}
}
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);
}
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 static async Task ReceiveMessagesAsync(IMessageSession session,
Queue <QueueMessage> queue,
int count)
{
var messages = await session.ReceiveAsync(count) ?? new List <Message>();
var queueMessages = messages.Where(m => m != null)
.Select(m => new QueueMessage(m));
foreach (var message in queueMessages)
{
var exampleClass =
JsonConvert.DeserializeObject <ExampleClass>(Encoding.UTF8.GetString(message.Body));
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine(
$"{DateTime.UtcNow:o} Message received:" +
$"\n\tSessionId = {message.SessionId}, " +
$"\n\tMessageId = {message.MessageId}, " +
$"\n\tSequenceNumber = {message.Message.SystemProperties.SequenceNumber}," +
$"\n\tContent: [ item = {exampleClass.ObjName} ]"
);
queue.Enqueue(message);
}
}
private async Task ProcessMessagesFromQueueSession()
{
try
{
_processID = System.Diagnostics.Process.GetCurrentProcess().Id;
_threadID = Thread.CurrentThread.ManagedThreadId;
_instanceID = Environment.GetEnvironmentVariable("WEBSITE_INSTANCE_ID");
//_tclient.TrackTrace($"InstanceID:{ _instanceid}");
#region receive the sessions from wo-xml and process the messages
_sessionClient.OperationTimeout = new TimeSpan(0, 0, 5);
//Console.WriteLine($"Start Receiving Session");
_tclient.TrackTrace($"InstanceID:{ _instanceID}, Start Receiving Session");
session = await _sessionClient.AcceptMessageSessionAsync();
if (session != null)
{
// Messages within a session will always arrive in order.
_tclient.TrackTrace($"InstanceID:{ _instanceID}, Received Session: [{session.SessionId}]");
while (true)
{
//Read All the messages from sessions
Message message = await session.ReceiveAsync();
if (message != null)
{
MemoryStream woBody = new MemoryStream(message.Body);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(woBody);
var wordOrderID = WOCommonUtility.GetNodeValue(xmlDoc, "Source_WO_ID");
var workOrderPriority = WOCommonUtility.GetNodeValue(xmlDoc, "WOPriority");
var workOrderSequence = WOCommonUtility.GetNodeValue(xmlDoc, "QueueSequence");
var workOrderPostedDateTime = WOCommonUtility.GetNodeValue(xmlDoc, "PostedDateTime");
string query = $"Insert into tblQueueLog (ProcessedBy,WorkOrder,Sequence,Priority,PostedTime,ProcessedTime,ProcessID,ThreadID, InstanceId) " +
$"values ('PocWebJob9090', '{wordOrderID}', '{workOrderSequence}', '{workOrderPriority}','{workOrderPostedDateTime}' , '{DateTime.UtcNow}','{_processID}','{_threadID }','{_instanceID}')";
await LogMesssagesInDb(query, _commonSettings.Value.SQLDBConnectionString);
// 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);
}
else
{
break;
}
}
}
else
{
//Console.WriteLine($"No any session available in queue to process from WebJob.");
}
}
catch (ServiceBusTimeoutException timeOutEx)
{
string query = $"Insert into tblQueueLog (ProcessedBy,ProcessedTime,ProcessID,ThreadID, InstanceId, ExceptionDetails ) " +
$"values ('PocWebJob9090', '{DateTime.UtcNow}','{_processID}','{_threadID}','{_instanceID}','Exception Type: ServiceBusTimeoutException, Queue session timed out')";
await LogMesssagesInDb(query, _commonSettings.Value.SQLDBConnectionString);
_tclient.TrackException(timeOutEx, new Dictionary <string, string>()
{
{ "ApplicationName", "PocWebJob9090" }, { "ModuleName", "Functions" }, { "Method", "ProcessMessagesFromQueue" },
{ "ServiceBusTimeoutException", "Service bus session timeout, No sessions in FIFO order." },
{ "InstanceID", _instanceID }, { "Message", timeOutEx.Message }
});
}
catch (SessionCannotBeLockedException lockedEx)
{
string query = $"Insert into tblQueueLog (ProcessedBy,ProcessedTime,ProcessID,ThreadID, InstanceId,ExceptionDetails ) " +
$"values ('PocWebJob9090', '{DateTime.UtcNow}','{_processID}','{_threadID }','{_instanceID}','Exception Type: SessionCannotBeLockedException, The requested session cannot be accepted. It may be locked by another receiver.')";
await LogMesssagesInDb(query, _commonSettings.Value.SQLDBConnectionString);
_tclient.TrackTrace($"The requested session cannot be accepted. It may be locked by another receiver.");
_tclient.TrackException(lockedEx, new Dictionary <string, string>()
{
{ "ApplicationName", "PocWebJob9090" }, { "ModuleName", "Functions" }, { "Method", "ProcessMessagesFromQueue" },
{ "SessionCannotBeLockedException", "The requested session cannot be accepted. It may be locked by another receiver." }, { "Message", lockedEx.Message },
{ "InstanceID", _instanceID }
});
}
catch (Exception ex)
{
string query = $"Insert into tblQueueLog (ProcessedBy,ProcessedTime,ProcessID,ThreadID,InstanceId,ExceptionDetails ) " +
$"values ('PocWebJob9090', '{DateTime.UtcNow}','{_processID}','{_threadID }','{_instanceID}','Exception Type: Exception, exception Occurred while going to fetch message from queue.')";
await LogMesssagesInDb(query, _commonSettings.Value.SQLDBConnectionString);
_tclient.TrackException(ex, new Dictionary <string, string>()
{
{ "ApplicationName", "PocWebJob9090" }, { "ModuleName", "Functions" }, { "Method", "ProcessMessagesFromQueue" },
{ "InstanceID", _instanceID }, { "Message", ex.Message }
});
}
#endregion
}
async Task MessagePumpTaskAsync(IMessageSession session)
{
if (session == null)
{
return;
}
CancellationTokenSource renewLockCancellationTokenSource = new CancellationTokenSource();
if (this.ShouldRenewSessionLock())
{
TaskExtensionHelper.Schedule(() => this.RenewSessionLockTaskAsync(session, renewLockCancellationTokenSource.Token));
}
Timer userCallbackTimer = new Timer(
OnUserCallBackTimeout,
renewLockCancellationTokenSource,
Timeout.Infinite,
Timeout.Infinite);
try
{
while (!this.pumpCancellationToken.IsCancellationRequested && !session.IsClosedOrClosing)
{
Message message;
try
{
message = await session.ReceiveAsync(this.sessionHandlerOptions.MessageWaitTimeout).ConfigureAwait(false);
}
catch (Exception exception)
{
MessagingEventSource.Log.MessageReceivePumpTaskException(this.clientId, session.SessionId, exception);
if (exception is ServiceBusTimeoutException)
{
// Timeout Exceptions are pretty common. Not alerting the User on this.
continue;
}
await this.RaiseExceptionReceived(exception, ExceptionReceivedEventArgsAction.Receive).ConfigureAwait(false);
break;
}
if (message == null)
{
MessagingEventSource.Log.SessionReceivePumpSessionEmpty(this.clientId, session.SessionId);
break;
}
// Set the timer
userCallbackTimer.Change(this.sessionHandlerOptions.MaxAutoRenewDuration, TimeSpan.FromMilliseconds(-1));
bool callbackExceptionOccured = false;
try
{
await this.userOnSessionCallback(session, message, this.pumpCancellationToken).ConfigureAwait(false);
}
catch (Exception exception)
{
MessagingEventSource.Log.MessageReceivePumpTaskException(this.clientId, session.SessionId, exception);
await this.RaiseExceptionReceived(exception, ExceptionReceivedEventArgsAction.UserCallback).ConfigureAwait(false);
callbackExceptionOccured = true;
if (!(exception is MessageLockLostException || exception is SessionLockLostException))
{
await this.AbandonMessageIfNeededAsync(session, message).ConfigureAwait(false);
}
}
finally
{
userCallbackTimer.Change(Timeout.Infinite, Timeout.Infinite);
}
if (!callbackExceptionOccured)
{
await this.CompleteMessageIfNeededAsync(session, message).ConfigureAwait(false);
}
else if (session.IsClosedOrClosing)
{
// If User closed the session as part of the callback, break out of the loop
break;
}
}
}
finally
{
userCallbackTimer.Dispose();
await this.CloseSessionIfNeededAsync(session).ConfigureAwait(false);
CancelAndDisposeCancellationTokenSource(renewLockCancellationTokenSource);
this.maxConcurrentSessionsSemaphoreSlim.Release();
}
}
async Task MessagePumpTaskAsync(IMessageSession session)
{
if (session == null)
{
return;
}
var renewLockCancellationTokenSource = new CancellationTokenSource();
if (this.ShouldRenewSessionLock())
{
TaskExtensionHelper.Schedule(() => this.RenewSessionLockTaskAsync(session, renewLockCancellationTokenSource.Token));
}
var autoRenewLockCancellationTimer = new Timer(
CancelAutoRenewLock,
renewLockCancellationTokenSource,
Timeout.Infinite,
Timeout.Infinite);
try
{
while (!this.pumpCancellationToken.IsCancellationRequested && !session.IsClosedOrClosing)
{
Message message;
try
{
message = await session.ReceiveAsync(this.sessionHandlerOptions.MessageWaitTimeout).ConfigureAwait(false);
}
catch (Exception exception)
{
MessagingEventSource.Log.MessageReceivePumpTaskException(this.clientId, session.SessionId, exception);
if (exception is ServiceBusTimeoutException)
{
// Timeout Exceptions are pretty common. Not alerting the User on this.
continue;
}
if (!(exception is ObjectDisposedException && this.pumpCancellationToken.IsCancellationRequested))
{
await this.RaiseExceptionReceived(exception, ExceptionReceivedEventArgsAction.Receive).ConfigureAwait(false);
}
break;
}
if (message == null)
{
MessagingEventSource.Log.SessionReceivePumpSessionEmpty(this.clientId, session.SessionId);
break;
}
bool isDiagnosticSourceEnabled = ServiceBusDiagnosticSource.IsEnabled();
Activity activity = isDiagnosticSourceEnabled ? this.diagnosticSource.ProcessSessionStart(session, message) : null;
Task processTask = null;
try
{
// Set the timer
autoRenewLockCancellationTimer.Change(this.sessionHandlerOptions.MaxAutoRenewDuration,
TimeSpan.FromMilliseconds(-1));
var callbackExceptionOccurred = false;
try
{
processTask = this.userOnSessionCallback(session, message, this.pumpCancellationToken);
await processTask.ConfigureAwait(false);
}
catch (Exception exception)
{
if (isDiagnosticSourceEnabled)
{
this.diagnosticSource.ReportException(exception);
}
MessagingEventSource.Log.MessageReceivePumpTaskException(this.clientId, session.SessionId, exception);
await this.RaiseExceptionReceived(exception, ExceptionReceivedEventArgsAction.UserCallback).ConfigureAwait(false);
callbackExceptionOccurred = true;
if (!(exception is MessageLockLostException || exception is SessionLockLostException))
{
await this.AbandonMessageIfNeededAsync(session, message).ConfigureAwait(false);
}
}
finally
{
autoRenewLockCancellationTimer.Change(Timeout.Infinite, Timeout.Infinite);
}
if (!callbackExceptionOccurred)
{
await this.CompleteMessageIfNeededAsync(session, message).ConfigureAwait(false);
}
else if (session.IsClosedOrClosing)
{
// If User closed the session as part of the callback, break out of the loop
break;
}
}
finally
{
this.diagnosticSource.ProcessSessionStop(activity, session, message, processTask?.Status);
}
}
}
finally
{
renewLockCancellationTokenSource.Cancel();
renewLockCancellationTokenSource.Dispose();
autoRenewLockCancellationTimer.Dispose();
await this.CloseSessionIfNeededAsync(session).ConfigureAwait(false);
this.maxConcurrentSessionsSemaphoreSlim.Release();
}
}
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?.LogTrace($"{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.CompleteAsync(msg.SystemProperties.LockToken);
}
await SendExceptionResponseIfRequired(msg, ex);
}
}
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;
}
}
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"));
}
