public async Task MessageIsLocked()
{
await Patiently.VerifyExpectationAsync(
() => MessageLock.Received().TryAquireLock(
Arg.Is <string>(a => a.Contains(DeserialisedMessage.Id.ToString())),
TimeSpan.FromSeconds(_expectedtimeout)));
}
public void MessageIsLocked()
{
var messageId = DeserializedMessage.Id.ToString();
MessageLock.Received().TryAquireLockAsync(
Arg.Is <string>(a => a.Contains(messageId)),
TimeSpan.FromSeconds(_maximumTimeout));
}
public async Task MessageIsLocked()
{
var messageId = DeserializedMessage.Id.ToString();
await MessageLock.Received().TryAquireLockAsync(
Arg.Is <string>(a => a.Contains(messageId, StringComparison.OrdinalIgnoreCase)),
TimeSpan.FromSeconds(_expectedTimeout));
}
public async Task MessageIsLocked()
{
var messageId = DeserialisedMessage.Id.ToString();
await MessageLock.Received().TryAquireLockAsync(
Arg.Is <string>(a => a.Contains(messageId)),
TimeSpan.FromSeconds(_expectedtimeout));
}
public async Task SendMessage(string message, string orgName, string senderConnectionID, HubConnection hubConnection)
{
try
{
if (await MessageLock.WaitAsync(30000))
{
ChatSession chatSession;
if (!ChatClients.Contains(senderConnectionID))
{
var rcBinaryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ScreenCast", OSUtils.ScreenCastExecutableFileName);
var procID = await AppLauncher.LaunchChatService(orgName, senderConnectionID, hubConnection);
var clientPipe = new NamedPipeClientStream(".", "Remotely_Chat" + senderConnectionID, PipeDirection.InOut, PipeOptions.Asynchronous);
clientPipe.Connect(15000);
if (!clientPipe.IsConnected)
{
Logger.Write("Failed to connect to chat host.");
return;
}
chatSession = new ChatSession()
{
PipeStream = clientPipe, ProcessID = procID
};
ChatClients.Add(senderConnectionID, chatSession, CacheItemPolicy);
}
chatSession = (ChatSession)ChatClients.Get(senderConnectionID);
if (!chatSession.PipeStream.IsConnected)
{
ChatClients.Remove(senderConnectionID);
await hubConnection.SendAsync("DisplayMessage", "Chat disconnected. Please try again.", "Chat disconnected.");
return;
}
using (var sw = new StreamWriter(chatSession.PipeStream, leaveOpen: true))
{
await sw.WriteLineAsync(message);
await sw.FlushAsync();
}
_ = Task.Run(async() => { await ReadFromStream(chatSession.PipeStream, senderConnectionID, hubConnection); });
}
}
catch (Exception ex)
{
Logger.Write(ex);
}
finally
{
MessageLock.Release();
}
}
protected override void Given()
{
base.Given();
_expectedtimeout = 5;
MessageLock = Substitute.For <IMessageLock>();
MessageLock.TryAquireLock(Arg.Any <string>(), Arg.Any <TimeSpan>()).Returns(new MessageLockResponse()
{
DoIHaveExclusiveLock = true
});
Handler = new MyHandler();
}
protected override async Task Given()
{
await base.Given();
var messageLockResponse = new MessageLockResponse
{
DoIHaveExclusiveLock = true
};
MessageLock = Substitute.For <IMessageLockAsync>();
MessageLock.TryAquireLockAsync(Arg.Any <string>(), Arg.Any <TimeSpan>())
.Returns(messageLockResponse);
_handler = new ExactlyOnceSignallingHandler(_tcs);
Handler = _handler;
}
protected override void Given()
{
base.Given();
_expectedtimeout = 5;
var messageLockResponse = new MessageLockResponse
{
DoIHaveExclusiveLock = true
};
MessageLock = Substitute.For <IMessageLock>();
MessageLock.TryAquireLock(Arg.Any <string>(), Arg.Any <TimeSpan>())
.Returns(messageLockResponse);
_handler = new ExplicitExactlyOnceSignallingHandler(_tcs);
Handler = _handler;
}
public Task <string> OpenAsync(CancellationToken cancellationToken)
{
// register the OnMessageAsync callback
_subscriptionClient.OnMessageAsync(
async message =>
{
using (var messageLock = new MessageLock(message))
{
_logger.StartContext(message.CorrelationId);
//make sure that the message is correct
if (message.Label != null &&
message.ContentType != null &&
message.ContentType.Equals("application/json", StringComparison.InvariantCultureIgnoreCase))
{
//var body = message.GetBody<Stream>();
//dynamic messageBody = JsonConvert.DeserializeObject(new StreamReader(body, true).ReadToEnd());
try
{
//callback for processing the message
await _callback(new ServiceBusSubscriptionListenerModel()
{
Message = message,
token = cancellationToken
});
}
catch (Exception ex)
{
//log it here and throw this will move message into dead-letter queue for retry.
_logger.LogError("Error while processing Funding calc message", ex);
throw;
}
}
//complete the message after processing
await messageLock.CompleteAsync();
}
},
new OnMessageOptions {
AutoComplete = false, MaxConcurrentCalls = 8
});
// Return the uri - in this case, that's just our connection string
return(Task.FromResult(_serviceBusConnectionString));
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue("TestQueue", new TestMessage());
Queues.Add(_queue);
var messageLockResponse = new MessageLockResponse
{
DoIHaveExclusiveLock = true
};
MessageLock = Substitute.For <IMessageLockAsync>();
MessageLock.TryAquireLockAsync(Arg.Any <string>(), Arg.Any <TimeSpan>())
.Returns(messageLockResponse);
_handler = new ExplicitExactlyOnceSignallingHandler(_tcs);
Handler = _handler;
}
public void MessageIsLockedWithCorrectTimeout()
{
Patiently.VerifyExpectation(() =>
MessageLock.Received().TryAquireLock(Arg.Any <string>(), TimeSpan.FromSeconds(_expectedtimeout)));
}
public void MessageIsLockedForTheRightId()
{
Patiently.VerifyExpectation(() =>
MessageLock.Received().TryAquireLock(Arg.Is <string>(a => a.Contains(DeserialisedMessage.Id.ToString())), Arg.Any <TimeSpan>()));
}
public async Task SendMessage(string senderName,
string message,
string orgName,
bool disconnected,
string senderConnectionID,
HubConnection hubConnection)
{
if (!await MessageLock.WaitAsync(30000))
{
Logger.Write("Timed out waiting for chat message lock.", Shared.Enums.EventType.Warning);
return;
}
try
{
ChatSession chatSession;
if (!ChatClients.Contains(senderConnectionID))
{
if (disconnected)
{
// Don't start a new session just to show a disconnected message.
return;
}
var procID = await AppLauncher.LaunchChatService(orgName, senderConnectionID, hubConnection);
if (procID > 0)
{
Logger.Write($"Chat app started. Process ID: {procID}");
}
else
{
Logger.Write($"Chat app did not start successfully.");
return;
}
var clientPipe = new NamedPipeClientStream(".", "Remotely_Chat" + senderConnectionID, PipeDirection.InOut, PipeOptions.Asynchronous);
clientPipe.Connect(15000);
if (!clientPipe.IsConnected)
{
Logger.Write("Failed to connect to chat host.");
return;
}
chatSession = new ChatSession()
{
PipeStream = clientPipe, ProcessID = procID
};
_ = Task.Run(async() => { await ReadFromStream(chatSession.PipeStream, senderConnectionID, hubConnection); });
ChatClients.Add(senderConnectionID, chatSession, CacheItemPolicy);
}
chatSession = (ChatSession)ChatClients.Get(senderConnectionID);
if (!chatSession.PipeStream.IsConnected)
{
ChatClients.Remove(senderConnectionID);
await hubConnection.SendAsync("DisplayMessage", "Chat disconnected. Please try again.", "Chat disconnected.", senderConnectionID);
return;
}
using var sw = new StreamWriter(chatSession.PipeStream, leaveOpen: true);
var chatMessage = new ChatMessage(senderName, message, disconnected);
await sw.WriteLineAsync(JsonSerializer.Serialize(chatMessage));
await sw.FlushAsync();
}
catch (Exception ex)
{
Logger.Write(ex);
}
finally
{
MessageLock.Release();
}
}