async Task SessionLockLostExceptionTest()
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, TestConstants.SessionNonPartitionedQueueName);
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}");
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}: LockedUntilUtc: {sessionReceiver.LockedUntilUtc}");
var message = await sessionReceiver.ReceiveAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Received Message: MessageId: {message.MessageId}");
// Let the Session expire with some buffer time
TestUtility.Log($"Waiting for session lock to time out...");
await Task.Delay((sessionReceiver.LockedUntilUtc - DateTime.UtcNow) + TimeSpan.FromSeconds(10));
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.ReceiveAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.RenewSessionLockAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.GetStateAsync());
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.SetStateAsync(null));
await Assert.ThrowsAsync <SessionLockLostException>(async() => await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken));
await sessionReceiver.CloseAsync();
TestUtility.Log($"Closed Session Receiver...");
//Accept a new Session and Complete the message
sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Received Session: SessionId: {sessionReceiver.SessionId}");
message = await sessionReceiver.ReceiveAsync();
TestUtility.Log($"Received Message: MessageId: {message.MessageId}");
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
await sessionReceiver.CloseAsync();
}
finally
{
await sender.CloseAsync();
await sessionClient.CloseAsync();
}
}
private static async Task ReceiveSessionMessages(string queueName)
{
var sessionClient = new SessionClient(SBConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
var session = await sessionClient.AcceptMessageSessionAsync();
if (session != null)
{
while (true)
{
var msg = await session.ReceiveAsync(TimeSpan.FromSeconds(2));
if (msg == null)
{
break;
}
var bodyAsString = Encoding.UTF8.GetString(msg.Body);
var seqNo = msg.SystemProperties.SequenceNumber;
Print.White($"{seqNo}--{msg.SessionId}--{bodyAsString}");
}
Console.WriteLine($"Received all messages for Session: {session.SessionId}");
Console.WriteLine("=====================================");
await session.CloseAsync();
}
}
private static async Task Send(string text)
{
var stopwatch = new Stopwatch();
#region ["Send A Simple Msg"]
Message simpleMessage = new Message
{
Body = StringSupport.GetBytes(text)
};
stopwatch.Start();
// Send the message on the request queue.
await mSimple.SendAsync(simpleMessage);
stopwatch.Stop();
Console.WriteLine("---");
Console.WriteLine("Simple Msg: {0} ms.", stopwatch.ElapsedMilliseconds);
#endregion
#region ["Send Req-Resp Msg"]
// Create a session identifyer for the response message
string responseSessionId = Guid.NewGuid().ToString();
// Create a message using text as the body.
Message requestMessage = new Message
{
SessionId = responseSessionId,
Body = StringSupport.GetBytes(text),
ReplyToSessionId = responseSessionId
};
Console.WriteLine("---");
Console.WriteLine("Sending request to RequestQueue for processing...");
stopwatch.Start();
// Send the message on the request queue.
await mSender.SendAsync(requestMessage);
// Accept a session message.
var responseSession = await mSessionRecvr.AcceptMessageSessionAsync(responseSessionId);
Message responseMessage = await responseSession.ReceiveAsync();
stopwatch.Stop();
await responseSession.CloseAsync();
#endregion
// Deserialise the message body to echoText.
string echoText = StringSupport.GetString(responseMessage.Body);
Console.WriteLine("Response rcvd from Server.");
Console.WriteLine(echoText);
Console.WriteLine("Req-Resp (Total) Time: {0} ms.", stopwatch.ElapsedMilliseconds);
}
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();
}
}
}
async Task EventsAreNotFiredWhenDiagnosticsIsDisabled()
{
this.messageSender = new MessageSender(TestUtility.NamespaceConnectionString,
TestConstants.SessionNonPartitionedQueueName);
this.sessionClient = new SessionClient(TestUtility.NamespaceConnectionString,
TestConstants.SessionNonPartitionedQueueName, ReceiveMode.ReceiveAndDelete);
this.listener.Disable();
var sessionId = Guid.NewGuid().ToString();
await this.messageSender.SendAsync(new Message
{
MessageId = "messageId",
SessionId = sessionId
});
this.messageSession = await sessionClient.AcceptMessageSessionAsync(sessionId);
await this.messageSession.SetStateAsync(new byte[] { 1 });
await this.messageSession.GetStateAsync();
await this.messageSession.SetStateAsync(new byte[] { });
await this.messageSession.ReceiveAsync();
Assert.True(events.IsEmpty);
}
private static async Task StartSessionSender(string sessionId, ConsoleColor color)
{
var message = new Message
{
ReplyToSessionId = sessionId,
ReplyTo = "sender"
};
var sender = new MessageSender(Configuration.ServiceBusConnectionString, "worker");
await sender.SendAsync(message);
Logger.Log($"[{sessionId}] write to worker queue", color);
var client = new SessionClient(Configuration.ServiceBusConnectionString, "sender");
var session = await client.AcceptMessageSessionAsync(sessionId, new TimeSpan(0, 1, 0));
while (true)
{
if (session.IsClosedOrClosing)
{
return;
}
var receivedMessage = await session.ReceiveAsync();
if (receivedMessage == null)
{
continue;
}
Logger.Log($"[{sessionId}] Received message {receivedMessage.UserProperties["result"]}", color);
await session.CompleteAsync(receivedMessage.SystemProperties.LockToken);
}
}
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 override MessageContext ReceiveOnTopic(MessageContext inputcontext, IMessageAdapter adapter)
{
var entity = EntityNameHelper.FormatSubscriptionPath(inputcontext.ToReplyPath, inputcontext.ToReplySubscription);
var client = new SessionClient(inputcontext.ToReplyConnectionString, entity);
var messagesession = client.AcceptMessageSessionAsync(inputcontext.ReplyToRequestId).GetAwaiter().GetResult();
var message = inputcontext.ToReplyTimeOut != 0 ? messagesession.ReceiveAsync(TimeSpan.FromSeconds(inputcontext.ToReplyTimeOut)).GetAwaiter().GetResult() : messagesession.ReceiveAsync().GetAwaiter().GetResult();
MessageContext outputcontext = null;
if (message != null)
{
outputcontext = adapter.Read(message, inputcontext.ResultType);
messagesession.CompleteAsync(message.SystemProperties.LockToken);
}
messagesession.CloseAsync().GetAwaiter().GetResult();
client.CloseAsync().GetAwaiter().GetResult();
return(outputcontext);
}
public async Task ReceiveDeferredMessageForSessionTest(string qName)
{
var sessionId = Guid.NewGuid().ToString("N").Substring(0, 8);
var messageId = Guid.NewGuid().ToString("N").Substring(0, 8);
var sender = new MessageSender(TestUtility.NamespaceConnectionString, qName);
await sender.SendAsync(new Message()
{
SessionId = sessionId, MessageId = messageId
});
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, qName);
var messageSession = await sessionClient.AcceptMessageSessionAsync(sessionId);
var msg = await messageSession.ReceiveAsync();
var seqNum = msg.SystemProperties.SequenceNumber;
await messageSession.DeferAsync(msg.SystemProperties.LockToken);
var msg2 = await messageSession.ReceiveDeferredMessageAsync(seqNum);
Assert.Equal(seqNum, msg2.SystemProperties.SequenceNumber);
Assert.Equal(messageId, msg2.MessageId);
await sender.CloseAsync();
await sessionClient.CloseAsync();
await messageSession.CloseAsync();
}
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();
}
}
async Task SessionRenewLockTest(string queueName)
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName);
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}");
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
TestUtility.Log($"Session LockedUntilUTC: {sessionReceiver.LockedUntilUtc} for Session: {sessionReceiver.SessionId}");
Message message = await sessionReceiver.ReceiveAsync();
TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
Assert.True(message.MessageId == messageId);
TestUtility.Log("Sleeping 10 seconds...");
await Task.Delay(TimeSpan.FromSeconds(10));
// For session it looks like when the session is received, sometimes the session LockedUntil UTC
// is turning out slightly more than the Default Lock Duration(lock is for 1 minute, but the session was locked
// for 1 min and 2 seconds. We will need to look at if this is an issue on service or some kind of time SKU.
// Temporarily changing this test to look at the renew request time instead.
DateTime renewRequestTime = DateTime.UtcNow;
await sessionReceiver.RenewSessionLockAsync();
DateTime firstLockedUntilUtcTime = sessionReceiver.LockedUntilUtc;
TestUtility.Log($"After Renew Session LockedUntilUTC: {firstLockedUntilUtcTime} for Session: {sessionReceiver.SessionId}");
Assert.True(firstLockedUntilUtcTime >= renewRequestTime + TimeSpan.FromSeconds(10));
TestUtility.Log("Sleeping 5 seconds...");
await Task.Delay(TimeSpan.FromSeconds(5));
renewRequestTime = DateTime.UtcNow;
await sessionReceiver.RenewSessionLockAsync();
TestUtility.Log($"After Second Renew Session LockedUntilUTC: {sessionReceiver.LockedUntilUtc} for Session: {sessionReceiver.SessionId}");
Assert.True(sessionReceiver.LockedUntilUtc >= renewRequestTime + TimeSpan.FromSeconds(5));
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}");
await sessionReceiver.CloseAsync();
}
finally
{
await sender.CloseAsync().ConfigureAwait(false);
await sessionClient.CloseAsync().ConfigureAwait(false);
}
}
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();
}
}
}
public async Task GetAndSetSessionStateTest(bool partitioned, bool sessionEnabled)
{
await ServiceBusScope.UsingQueueAsync(partitioned, sessionEnabled, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName);
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}");
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
Assert.NotNull(sessionReceiver);
var message = await sessionReceiver.ReceiveAsync();
TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
Assert.True(message.MessageId == messageId);
var sessionStateString = "Received Message From Session!";
var sessionState = Encoding.UTF8.GetBytes(sessionStateString);
await sessionReceiver.SetStateAsync(sessionState);
TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}");
var returnedSessionState = await sessionReceiver.GetStateAsync();
var returnedSessionStateString = Encoding.UTF8.GetString(returnedSessionState);
TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}");
Assert.Equal(sessionStateString, returnedSessionStateString);
// Complete message using Session Receiver
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}");
sessionStateString = "Completed Message On Session!";
sessionState = Encoding.UTF8.GetBytes(sessionStateString);
await sessionReceiver.SetStateAsync(sessionState);
TestUtility.Log($"Set Session State: {sessionStateString} for Session: {sessionReceiver.SessionId}");
returnedSessionState = await sessionReceiver.GetStateAsync();
returnedSessionStateString = Encoding.UTF8.GetString(returnedSessionState);
TestUtility.Log($"Get Session State Returned: {returnedSessionStateString} for Session: {sessionReceiver.SessionId}");
Assert.Equal(sessionStateString, returnedSessionStateString);
await sessionReceiver.CloseAsync();
}
finally
{
await sender.CloseAsync();
await sessionClient.CloseAsync();
}
});
}
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);
}
private static async Task ReadMessage(string connectionString, string sessionId)
{
var sessionClient = new SessionClient(connectionString, "session-queue-test");
var session = await sessionClient.AcceptMessageSessionAsync(sessionId);
var message = await session.ReceiveAsync();
await session.CompleteAsync(message.SystemProperties.LockToken);
string messageBody = Encoding.UTF8.GetString(message.Body);
Console.WriteLine("Message received: {0}", messageBody);
}
static async Task Main(string[] args)
{
Console.WriteLine("Client Console");
while (true)
{
Console.WriteLine("Enter text:");
string text = Console.ReadLine();
// Create a session identifier for the response message
string responseSessionId = Guid.NewGuid().ToString();
// Create a message using text as the body.
var requestMessage = new Message(Encoding.UTF8.GetBytes(text));
// Set the appropriate message properties.
//Send the first message to the first queue with the
// responseID set
requestMessage.ReplyToSessionId = responseSessionId;
var stopwatch = Stopwatch.StartNew();
// Send the message on the request queue.
await RequestQueueClient.SendAsync(requestMessage);
// Create a session client
// wait for the server to responsd with the same SessionId
// by creating a session client
var sessionClient =
new SessionClient("ConnectionString", "QueueName");
// Accept a message session
var messageSession = await sessionClient.AcceptMessageSessionAsync(responseSessionId);
// Receive the response message.
var responseMessage = await messageSession.ReceiveAsync();
stopwatch.Stop();
// Close the session, we got the message.
await sessionClient.CloseAsync();
// Deserialise the message body to echoText.
string echoText = Encoding.UTF8.GetString(responseMessage.Body);
Console.WriteLine(echoText);
Console.WriteLine("Time: {0} ms.", stopwatch.ElapsedMilliseconds);
Console.WriteLine();
}
}
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 QueueSessionEventsAreNotFiredWhenDiagnosticsIsDisabled()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : true, async queueName =>
{
var messageSender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var sessionClient = new SessionClient(TestUtility.NamespaceConnectionString, queueName, ReceiveMode.ReceiveAndDelete);
var messageSession = default(IMessageSession);
var eventQueue = this.CreateEventQueue();
try
{
using (var listener = this.CreateEventListener(queueName, eventQueue))
using (var subscription = this.SubscribeToEvents(listener))
{
listener.Disable();
var sessionId = Guid.NewGuid().ToString();
await messageSender.SendAsync(new Message
{
MessageId = "messageId",
SessionId = sessionId
});
messageSession = await sessionClient.AcceptMessageSessionAsync(sessionId);
await messageSession.SetStateAsync(new byte[] { 1 });
await messageSession.GetStateAsync();
await messageSession.SetStateAsync(new byte[] { });
await messageSession.ReceiveAsync();
Assert.True(eventQueue.IsEmpty, "There were events present when none were expected");
}
}
finally
{
await Task.WhenAll(
messageSession?.CloseAsync(),
messageSender.CloseAsync(),
sessionClient.CloseAsync());
}
});
}
public async Task <T> RecibeMensajeSesion(string cadenaConexion, string nombreCola, string sesionId, int segundos, int intentos)
{
int contador = 0;
T respuesta = default(T);
var serviceBusConnectionStringBuilder = new ServiceBusConnectionStringBuilder(cadenaConexion);
var serviceBusConnection = new ServiceBusConnection(serviceBusConnectionStringBuilder);
var sessionClient = new SessionClient(serviceBusConnection, nombreCola, ReceiveMode.PeekLock, null, 0);
var messageSession = await sessionClient.AcceptMessageSessionAsync(sesionId, TimeSpan.FromMinutes(1));
if (messageSession != null)
{
while (contador < intentos)
{
Message message = await messageSession.ReceiveAsync(TimeSpan.FromSeconds(5));
if (message != null)
{
var bodyText = System.Text.Encoding.UTF8.GetString(message.Body);
respuesta = JsonConvert.DeserializeObject <T>(bodyText);
await messageSession.CompleteAsync(message.SystemProperties.LockToken);
contador = intentos;
}
else
{
await Task.Delay(segundos * 1000);
}
contador++;
}
}
await messageSession.CloseAsync();
await sessionClient.CloseAsync();
await serviceBusConnection.CloseAsync();
return(respuesta);
}
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);
}
async Task AcceptAndCompleteSessionsAsync(SessionClient sessionClient, string sessionId, string messageId)
{
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
if (sessionId != null)
{
Assert.True(sessionReceiver.SessionId == sessionId);
}
var message = await sessionReceiver.ReceiveAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
await sessionReceiver.CompleteAsync(message.SystemProperties.LockToken);
TestUtility.Log($"Completed Message: {message.MessageId} for Session: {sessionReceiver.SessionId}");
await sessionReceiver.CloseAsync();
}
async Task PeekAndDeleteMessageAsync(SessionClient sessionClient, string sessionId, string messageId)
{
var sessionReceiver = await sessionClient.AcceptMessageSessionAsync(sessionId);
if (sessionId != null)
{
Assert.True(sessionReceiver.SessionId == sessionId);
}
var message = await sessionReceiver.PeekAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Peeked Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
message = await sessionReceiver.ReceiveAsync();
Assert.True(message.MessageId == messageId);
TestUtility.Log($"Received Message: {message.MessageId} from Session: {sessionReceiver.SessionId}");
await sessionReceiver.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();
}
});
}
public async Task <TResponse> SendRequest(TRequest request)
{
var sw = new Stopwatch();
sw.Start();
var sessionId = Guid.NewGuid().ToString("N");
var message = Helpers.CreateMessage(request);
message.ReplyTo = receiveResponseQueueName;
message.ReplyToSessionId = sessionId;
var sessionClient = new SessionClient(connectionStr, receiveResponseQueueName);
var messageSession = await sessionClient.AcceptMessageSessionAsync(sessionId);
var receiveTask = messageSession.ReceiveAsync(TimeSpan.FromSeconds(20));
// SEND!
RequestSending?.Invoke(request, message);
await client.SendAsync(message);
// RECEIVE!
var responseMsg = await receiveTask;
await messageSession.CloseAsync();
sw.Stop();
AverageRTTms = (AverageRTTms * sendCount + sw.ElapsedMilliseconds) / (++sendCount);
if (sw.ElapsedMilliseconds < MinRTTms || MinRTTms == 0)
{
MinRTTms = sw.ElapsedMilliseconds;
}
if (sw.ElapsedMilliseconds > MaxRTTms)
{
MaxRTTms = sw.ElapsedMilliseconds;
}
return(Helpers.DecodeMessage <TResponse>(responseMsg));
}
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);
}
public override MessageContext ReceiveOnQueue(Channel channel, MessageContext context, IMessageAdapter adapter)
{
var client = new SessionClient(channel.ToReplyConnectionString, channel.ToReplyPath);
var messagesession = client.AcceptMessageSessionAsync(context.Identity.ReplyToRequestId).GetAwaiter().GetResult();
var message = channel.ToReplyTimeOut != 0 ? messagesession.ReceiveAsync(TimeSpan.FromSeconds(channel.ToReplyTimeOut)).GetAwaiter().GetResult() : messagesession.ReceiveAsync().GetAwaiter().GetResult();
MessageContext outputcontext = null;
if (message != null)
{
outputcontext = adapter.Read(message, context.ResultType, context.EndPoint.UseClaimCheck);
messagesession.CompleteAsync(message.SystemProperties.LockToken);
}
messagesession.CloseAsync().GetAwaiter().GetResult();
client.CloseAsync().GetAwaiter().GetResult();
return(outputcontext);
}
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();
}
}
}
private static async Task InitializeReceiver(string connectionString, string queueName)
{
var sessionClient = new SessionClient(connectionString, queueName, ReceiveMode.PeekLock);
var expectedLockMessage = RandomBreakingMessage().ToList();
while (true)
{
IMessageSession session;
try
{
session = await sessionClient.AcceptMessageSessionAsync("session", TimeSpan.FromMinutes(1));
}
catch (Exception e)
{
Console.WriteLine(e);
continue;
}
var queue = new Queue <QueueMessage>();
try
{
await ReceiveMessagesAsync(session, queue, 10);
foreach (var message in new Queue <QueueMessage>(queue))
{
await ProcessMessage(message, expectedLockMessage);
await ConsumeComplete(session, queue, message.LockToken);
}
}
catch (Exception e)
{
Console.WriteLine(e);
await session.CloseAsync();
}
}
}
