private async Task RandomClient(IWorkContext context, MonitorReport report, int clientNumber, CancellationToken token)
{
string agentName = $"{_options.AgentName}_Send_{clientNumber}";
AgentContractV1 agent = (await _client.Message.GetAgentId(context, _options.QueueName, agentName)).Value;
using (var monitor = new MonitorRate(report, agentName))
{
while (!token.IsCancellationRequested)
{
try
{
EnqueueMessageContractV1 request = CreateMessage(context, agent.AgentId, _options.QueueName);
RestResponse <EnqueuedContractV1> response = await _client.Message.EnqueueMessage(context, request);
if (response.StatusCode != HttpStatusCode.OK)
{
monitor.IncrementError();
continue;
}
monitor.IncrementNew();
await Utility.Delay(_options.Delay, token);
}
catch
{
monitor.IncrementError();
}
}
}
}
public async Task <IActionResult> EnqueueMessage(string queueName, [FromBody] EnqueueMessageContractV1 contract)
{
Verify.IsNotEmpty(nameof(queueName), queueName);
Verify.IsNotNull(nameof(contract), contract);
RequestContext requestContext = HttpContext.GetRequestContext();
var context = requestContext.Context.WithTag(_tag);
long messageId;
try
{
messageId = await _message.EnqueueMessage(context, contract.ConvertTo());
}
catch (QueueFullException ex)
{
return(new StandardActionResult(context, HttpStatusCode.Conflict)
.SetContent($"Queue is full {ex.Message}"));
}
var response = new EnqueuedContractV1
{
MessageId = messageId,
};
return(new StandardActionResult(context)
.SetContent(response));
}
public async Task SimpleScheduleSuccessTestApi()
{
var context = _workContext.WithTag(_tag);
AgentContractV1 agent = await _utility.SetupAgentAndQueue(_queueName, _agentName);
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
message.ScheduleDate = DateTime.UtcNow.AddSeconds(2);
await _client.Message.EnqueueMessage(context, message);
await _utility.VerifyQueue(context, _queueName, 0, 1);
MessageContractV1 readMessage = (await _client.Message.DequeueMessageAndDelete(context, _queueName, null)).Value;
readMessage.Should().BeNull();
await Task.Delay(TimeSpan.FromSeconds(10));
readMessage = (await _client.Message.DequeueMessageAndDelete(context, _queueName, null)).Value;
_utility.VerifyMessage(message, readMessage, agent.AgentId, false);
HistoryContractV1 history = (await _client.History.GetHistory(context, readMessage.MessageId)).Value;
_utility.VerifyHistoryMessage(readMessage, history, _queueName, _agentName);
}
public async Task ListActiveQueueTestApi()
{
const int messageSize = 100;
var context = _workContext.WithTag(_tag);
AgentContractV1 agent = await _utility.SetupAgentAndQueue(_queueName, _agentName);
var messageList = new List <EnqueueMessageContractV1>();
foreach (int index in Enumerable.Range(0, messageSize))
{
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
messageList.Add(message);
await _client.Message.EnqueueMessage(context, message);
}
await _utility.VerifyQueue(context, _queueName, messageSize, 0);
IEnumerable <MessageContractV1> activeMessage = (await _client.Message.GetActiveMessages(context, _queueName)).Value.Items;
var zip = messageList
.OrderBy(x => x.ClientMessageId)
.Zip(activeMessage.OrderBy(x => x.ClientMessageId), (f, s) => new Tuple <EnqueueMessageContractV1, MessageContractV1>(f, s));
}
public async Task SimpleEnqueueWithLockSuccessTestApi()
{
var context = _workContext.WithTag(_tag);
AgentContractV1 agent = await _utility.SetupAgentAndQueue(_queueName, _agentName);
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
await _client.Message.EnqueueMessage(context, message);
await _utility.VerifyQueue(context, _queueName, 1, 0);
MessageContractV1 readMessage = (await _client.Message.DequeueMessageWithLock(context, _queueName, agent, null)).Value;
_utility.VerifyMessage(message, readMessage, agent.AgentId, true);
var settleMessage = new SettleMessageContractV1
{
AgentId = agent.AgentId,
QueueName = _queueName,
SettleType = SettleType.Processed,
MessageId = readMessage.MessageId,
};
await _client.Message.SettleMessage(context, settleMessage);
await _utility.VerifyQueue(context, _queueName, 0, 0);
HistoryContractV1 history = (await _client.History.GetHistory(context, readMessage.MessageId)).Value;
_utility.VerifyHistoryMessage(readMessage, history, _queueName, _agentName);
}
public async Task MultipleScheduleSuccessTestApi()
{
const int scheduleSize = 10;
var context = _workContext.WithTag(_tag);
AgentContractV1 agent = await _utility.SetupAgentAndQueue(_queueName, _agentName);
var list = new List <EnqueueMessageContractV1>();
foreach (var item in Enumerable.Range(0, scheduleSize))
{
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
message.ScheduleDate = DateTime.UtcNow.AddSeconds(2);
await _client.Message.EnqueueMessage(context, message);
list.Add(message);
}
await _utility.VerifyQueue(context, _queueName, 0, scheduleSize);
MessageContractV1 readMessage = (await _client.Message.DequeueMessageAndDelete(context, _queueName, null)).Value;
readMessage.Should().BeNull();
await Task.Delay(TimeSpan.FromSeconds(10));
var readList = new List <MessageContractV1>();
foreach (var item in Enumerable.Range(0, scheduleSize))
{
readMessage = (await _client.Message.DequeueMessageAndDelete(context, _queueName, null)).Value;
readMessage.Should().NotBeNull();
readList.Add(readMessage);
}
readList.Count.Should().Be(scheduleSize);
readMessage = (await _client.Message.DequeueMessageAndDelete(context, _queueName, null)).Value;
readMessage.Should().BeNull();
var zip = list
.OrderBy(x => x.ClientMessageId)
.Zip(readList.OrderBy(x => x.ClientMessageId), (f, s) => new Tuple <EnqueueMessageContractV1, MessageContractV1>(f, s));
foreach (var item in zip)
{
_utility.VerifyMessage(item.Item1, item.Item2, agent.AgentId, false);
}
await _utility.VerifyQueue(context, _queueName, 0, 0);
foreach (var item in readList)
{
HistoryContractV1 history = (await _client.History.GetHistory(context, item.MessageId)).Value;
_utility.VerifyHistoryMessage(item, history, _queueName, _agentName);
}
}
/// <summary>
/// Enqueue a message
/// </summary>
/// <param name="context">context</param>
/// <param name="message">message to send</param>
/// <returns>task</returns>
public async Task Enqueue(IWorkContext context, T message)
{
Verify.IsNotNull(nameof(context), context);
Verify.IsNotNull(nameof(message), message);
context = context.WithTag(_tag);
await EnableQueue(context);
EnqueueMessageContractV1 request = await CreateMessage(context, message);
RestResponse <EnqueuedContractV1> response = await Client.Message.EnqueueMessage(context, request);
Verify.IsNotNull(nameof(response), response);
}
private async Task WriteQueue(IWorkContext context, int agentId, CancellationToken token)
{
while (!token.IsCancellationRequested)
{
try
{
await Task.Delay(TimeSpan.FromMilliseconds(10), token);
}
catch
{
continue;
}
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agentId, _queueName);
await _client.Message.EnqueueMessage(context, message);
Interlocked.Increment(ref _writeCounter);
}
}
public async Task SimpleEnqueueWithLockTimeoutSuccessTestApi()
{
var context = _workContext.WithTag(_tag);
AgentContractV1 agent = await _utility.SetupAgentAndQueue(_queueName, _agentName, lockValidForSec : 5);
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
await _client.Message.EnqueueMessage(context, message);
await _utility.VerifyQueue(context, _queueName, 1, 0);
MessageContractV1 readMessage = (await _client.Message.DequeueMessageWithLock(context, _queueName, agent, null)).Value;
long saveMessageId = readMessage.MessageId;
_utility.VerifyMessage(message, readMessage, agent.AgentId, true);
MessageContractV1 tempMessage = (await _client.Message.DequeueMessageWithLock(context, _queueName, agent, null)).Value;
tempMessage.Should().BeNull();
await Task.Delay(TimeSpan.FromSeconds(10));
readMessage = (await _client.Message.DequeueMessageWithLock(context, _queueName, agent, null)).Value;
_utility.VerifyMessage(message, readMessage, agent.AgentId, true);
readMessage.MessageId.Should().Be(saveMessageId);
var settleMessage = new SettleMessageContractV1
{
AgentId = agent.AgentId,
QueueName = _queueName,
SettleType = SettleType.Processed,
MessageId = readMessage.MessageId,
};
await _client.Message.SettleMessage(context, settleMessage);
await _utility.VerifyQueue(context, _queueName, 0, 0);
HistoryContractV1 history = (await _client.History.GetHistory(context, readMessage.MessageId)).Value;
_utility.VerifyHistoryMessage(readMessage, history, _queueName, _agentName, retryCount: 2);
}
public async Task SimpleClearQueueHistoryTestApi()
{
var context = _workContext.WithTag(_tag);
AgentContractV1 agent = await _utility.SetupAgentAndQueue(_queueName, _agentName);
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
RestResponse <EnqueuedContractV1> response = await _client.Message.EnqueueMessage(context, message);
await _utility.VerifyQueue(context, _queueName, 1, 0);
await _client.Management.ClearQueue(context, _queueName, true);
await _utility.VerifyQueue(context, _queueName, 0, 0);
HistoryContractV1 history = (await _client.History.GetHistory(context, response.Value.MessageId)).Value;
history.Should().NotBeNull();
}
public void VerifyMessage(EnqueueMessageContractV1 message, MessageContractV1 readMessage, int agentId, bool testLock)
{
readMessage.Should().NotBeNull();
readMessage.QueueId.Should().BeGreaterOrEqualTo(0);
readMessage.MessageId.Should().BeGreaterOrEqualTo(0);
readMessage.CreatedByAgentId.Should().Be(agentId);
readMessage.ClientMessageId.Should().Be(message.ClientMessageId);
readMessage.Cv.Should().Be(message.Cv);
readMessage.Payload.Should().Be(message.Payload);
if (testLock)
{
readMessage.LockedByAgentId.Should().Be(agentId);
}
WorkRequest readWorkRequest = readMessage.Deserialize <WorkRequest>();
readWorkRequest.Should().NotBeNull();
readWorkRequest.ProcessName.Should().Be("this process");
readWorkRequest.Parameters.Should().NotBeNull();
readWorkRequest.Parameters.Count().Should().Be(3);
}
public async Task SimpleEnqueueSuccessTestApi()
{
var context = _workContext.WithTag(_tag);
AgentContractV1 agent = await _utility.SetupAgentAndQueue(_queueName, _agentName);
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
await _client.Message.EnqueueMessage(context, message);
await _utility.VerifyQueue(context, _queueName, 1, 0);
MessageContractV1 readMessage = (await _client.Message.DequeueMessageAndDelete(context, _queueName, null)).Value;
_utility.VerifyMessage(message, readMessage, agent.AgentId, false);
await _utility.VerifyQueue(context, _queueName, 0, 0);
HistoryContractV1 history = (await _client.History.GetHistory(context, readMessage.MessageId)).Value;
_utility.VerifyHistoryMessage(readMessage, history, _queueName, _agentName);
}
public async Task QueueSizeLimitTestApi()
{
const int messageSize = 10;
var context = _workContext.WithTag(_tag);
AgentContractV1 agent = await _utility.SetupAgentAndQueue(_queueName, _agentName, queueSize : 10);
var messageList = new List <EnqueueMessageContractV1>();
var readMessageList = new List <MessageContractV1>();
foreach (int index in Enumerable.Range(0, messageSize))
{
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
messageList.Add(message);
await _client.Message.EnqueueMessage(context, message);
}
await Verify.AssertExceptionAsync <RestConflictException>(async() =>
{
EnqueueMessageContractV1 message = _utility.CreateMessage(context, agent.AgentId, _queueName);
await _client.Message.EnqueueMessage(context, message);
});
await _utility.VerifyQueue(context, _queueName, messageSize, 0);
MessageContractV1 readMessage;
foreach (int index in Enumerable.Range(0, messageSize))
{
readMessage = (await _client.Message.DequeueMessageWithLock(context, _queueName, agent, null)).Value;
readMessage.Should().NotBeNull();
readMessageList.Add(readMessage);
}
readMessage = (await _client.Message.DequeueMessageWithLock(context, _queueName, agent, null)).Value;
readMessage.Should().BeNull();
var zip = messageList
.OrderBy(x => x.ClientMessageId)
.Zip(readMessageList.OrderBy(x => x.ClientMessageId), (f, s) => new Tuple <EnqueueMessageContractV1, MessageContractV1>(f, s));
foreach (var item in zip)
{
_utility.VerifyMessage(item.Item1, item.Item2, agent.AgentId, true);
}
foreach (var item in readMessageList)
{
var settleMessage = new SettleMessageContractV1
{
AgentId = agent.AgentId,
QueueName = _queueName,
SettleType = SettleType.Processed,
MessageId = item.MessageId,
};
await _client.Message.SettleMessage(context, settleMessage);
}
await _utility.VerifyQueue(context, _queueName, 0, 0);
foreach (var item in readMessageList)
{
HistoryContractV1 history = (await _client.History.GetHistory(context, item.MessageId)).Value;
_utility.VerifyHistoryMessage(item, history, _queueName, _agentName);
}
}
/// <summary>
/// Enqueue a message
///
/// If the "ScheduleDate" of the contract is specified, this will schedule a message
/// </summary>
/// <param name="context">context</param>
/// <param name="queueName">queue name</param>
/// <param name="contract">contract for the message</param>
/// <returns>200 will return message id (long), all other codes are errors</returns>
public async Task <RestResponse <EnqueuedContractV1> > EnqueueMessage(IWorkContext context, EnqueueMessageContractV1 contract)
{
Verify.IsNotNull(nameof(context), context);
Verify.IsNotNull(nameof(contract), contract);
Verify.IsNotEmpty(nameof(contract.QueueName), contract.QueueName);
context = context.WithTag(_tag);
return(await CreateClient()
.AddPath(contract.QueueName)
.AddPath("message/head")
.SetContent(contract)
.PostAsync(context)
.ToRestResponseAsync(context)
.EnsureSuccessStatusCodeAsync(context)
.GetContentAsync <EnqueuedContractV1>(context));
}
