public async Task PumpMessagesTest()
{
// Arrange
const int MessagesCount = 10;
const string EndpointId = "endpoint1";
var endpoint = new TestEndpoint(EndpointId);
ICheckpointer checkpointer = await Checkpointer.CreateAsync(EndpointId, new CheckpointStore());
var endpointExecutorConfig = new EndpointExecutorConfig(TimeSpan.FromHours(1), RetryStrategy.NoRetry, TimeSpan.FromHours(1));
var asyncEndpointExecutorOptions = new AsyncEndpointExecutorOptions(4, TimeSpan.FromSeconds(2));
var messageStore = new TestMessageStore();
var storingAsyncEndpointExecutor = new StoringAsyncEndpointExecutor(endpoint, checkpointer, endpointExecutorConfig, asyncEndpointExecutorOptions, messageStore);
IEnumerable <IMessage> messages = GetNewMessages(MessagesCount, 0);
// Act - Send messages to invoke
foreach (IMessage message in messages)
{
await storingAsyncEndpointExecutor.Invoke(message);
}
await Task.Delay(TimeSpan.FromSeconds(10));
// Assert - Make sure the endpoint received all the messages.
Assert.Equal(MessagesCount, endpoint.N);
for (int i = 0; i < MessagesCount; i++)
{
IMessage message = endpoint.Processed[i];
Assert.True(message.Properties.ContainsKey($"key{i}"));
Assert.Equal($"value{i}", message.Properties[$"key{i}"]);
}
}
public async Task SmokeTest()
{
var endpoint = new TestEndpoint("id");
Checkpointer checkpointer = await Checkpointer.CreateAsync("exec1", NullCheckpointStore.Instance);
var executor = new SyncEndpointExecutor(endpoint, checkpointer);
var expected = new List <IMessage> {
Message1, Message2, Message3
};
Assert.Equal(State.Idle, executor.Status.State);
Assert.Equal(Checkpointer.InvalidOffset, executor.Status.CheckpointerStatus.Offset);
Assert.Equal(Checkpointer.InvalidOffset, executor.Status.CheckpointerStatus.Proposed);
foreach (IMessage msg in expected)
{
await executor.Invoke(msg);
}
await executor.CloseAsync();
Assert.Equal(3, endpoint.N);
Assert.Equal(expected, endpoint.Processed);
Assert.Equal(3, executor.Status.CheckpointerStatus.Offset);
Assert.Equal(3, executor.Status.CheckpointerStatus.Proposed);
}
public async Task SmokeTest()
{
var endpoint = new TestEndpoint("id");
Checkpointer checkpointer = await Checkpointer.CreateAsync("exec1", NullCheckpointStore.Instance);
var executor = new AsyncEndpointExecutor(endpoint, checkpointer, MaxConfig, new AsyncEndpointExecutorOptions(1));
var expected = new List <IMessage> {
Message1, Message2, Message3
};
Assert.Equal(State.Idle, executor.Status.State);
Assert.Equal(Checkpointer.InvalidOffset, executor.Status.CheckpointerStatus.Offset);
Assert.Equal(Checkpointer.InvalidOffset, executor.Status.CheckpointerStatus.Proposed);
foreach (IMessage msg in expected)
{
await executor.Invoke(msg, 0, 3600);
}
await Task.Delay(TimeSpan.FromSeconds(2));
await executor.CloseAsync();
Assert.Equal(3, endpoint.N);
Assert.Equal(expected, endpoint.Processed);
Assert.Equal(3, executor.Status.CheckpointerStatus.Offset);
Assert.Equal(3, executor.Status.CheckpointerStatus.Proposed);
}
public async Task TestSetEndpoint()
{
var endpoint1 = new TestEndpoint("id");
var endpoint2 = new NullEndpoint("id");
var endpoint3 = new TestEndpoint("id1");
ICheckpointer checkpointer = await Checkpointer.CreateAsync("cid", new CheckpointStore());
var endpointExecutorConfig = new EndpointExecutorConfig(TimeSpan.FromHours(1), RetryStrategy.NoRetry, TimeSpan.FromHours(1));
var asyncEndpointExecutorOptions = new AsyncEndpointExecutorOptions(1, TimeSpan.FromSeconds(1));
var messageStore = new TestMessageStore();
var executor = new StoringAsyncEndpointExecutor(endpoint1, checkpointer, endpointExecutorConfig, asyncEndpointExecutorOptions, messageStore);
Assert.Equal(endpoint1, executor.Endpoint);
await Assert.ThrowsAsync <ArgumentNullException>(() => executor.SetEndpoint(null));
await Assert.ThrowsAsync <ArgumentException>(() => executor.SetEndpoint(endpoint3));
await executor.SetEndpoint(endpoint2);
Assert.Equal(endpoint2, executor.Endpoint);
await executor.CloseAsync();
await Assert.ThrowsAsync <InvalidOperationException>(() => executor.SetEndpoint(endpoint1));
}
public async Task TestClose()
{
var store = new Mock <ICheckpointStore>();
store.Setup(d => d.GetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(10));
using (ICheckpointer checkpointer1 = await Checkpointer.CreateAsync("id1", store.Object))
{
await checkpointer1.CommitAsync(new[] { MessageWithOffset(20) }, new IMessage[] { }, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None);
Assert.Equal(20, checkpointer1.Offset);
await checkpointer1.CloseAsync(CancellationToken.None);
await Assert.ThrowsAsync <InvalidOperationException>(() => checkpointer1.CommitAsync(new[] { MessageWithOffset(30) }, new IMessage[] { }, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None));
// close a second time
await checkpointer1.CloseAsync(CancellationToken.None);
await Assert.ThrowsAsync <InvalidOperationException>(() => checkpointer1.CommitAsync(new[] { MessageWithOffset(40) }, new IMessage[] { }, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None));
Assert.Equal(20, checkpointer1.Offset);
bool result = checkpointer1.Admit(MessageWithOffset(30));
Assert.False(result);
}
}
public async Task TestCommit(Message message, long offset, long expected)
{
var store = new Mock <ICheckpointStore>();
store.Setup(d => d.GetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(offset));
using (ICheckpointer checkpointer1 = await Checkpointer.CreateAsync("id1", store.Object))
{
await checkpointer1.CommitAsync(new IMessage[] { message }, new IMessage[] { }, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None);
Assert.Equal(expected, checkpointer1.Offset);
Expression <Func <CheckpointData, bool> > expr = obj => obj.Offset == expected;
if (message.Offset == expected && message.Offset != offset)
{
// this is a valid commit and the store should update
store.Verify(d => d.SetCheckpointDataAsync("id1", It.Is(expr), It.IsAny <CancellationToken>()), Times.Exactly(1));
}
else
{
store.Verify(d => d.SetCheckpointDataAsync(It.IsAny <string>(), new CheckpointData(It.IsAny <long>()), It.IsAny <CancellationToken>()), Times.Never);
}
await checkpointer1.CloseAsync(CancellationToken.None);
}
}
public async Task TestStatus()
{
var checkpointerStore = new Mock <ICheckpointStore>();
checkpointerStore.Setup(c => c.GetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(0L));
checkpointerStore.Setup(c => c.SetCheckpointDataAsync(It.IsAny <string>(), new CheckpointData(It.IsAny <long>()), It.IsAny <CancellationToken>())).Returns(TaskEx.Done);
ICheckpointer checkpointer = await Checkpointer.CreateAsync("checkpoint.id1", checkpointerStore.Object);
var endpoint = new TestEndpoint("endpoint1");
using (var executor = new AsyncEndpointExecutor(endpoint, checkpointer, MaxConfig, new AsyncEndpointExecutorOptions(1)))
{
await executor.Invoke(Message1, 0, 3600);
await Task.Delay(TimeSpan.FromSeconds(2));
await executor.CloseAsync();
Assert.Equal(1, endpoint.N);
EndpointExecutorStatus status = executor.Status;
Assert.Equal("endpoint1", status.Id);
Assert.Equal(0, status.RetryAttempts);
Assert.Equal(State.Closed, status.State);
Assert.Equal("checkpoint.id1", status.CheckpointerStatus.Id);
Assert.Equal(1, status.CheckpointerStatus.Offset);
}
}
public async Task <IEndpointExecutor> CreateAsync(Endpoint endpoint, IList <uint> priorities)
{
ICheckpointer checkpointer = await Checkpointer.CreateAsync(endpoint.Id, this.store);
IEndpointExecutor executor = await this.underlying.CreateAsync(endpoint, priorities, checkpointer);
return(executor);
}
/// <summary>
/// This checkpoints the specified checkpointer with retries.
/// </summary>
/// <param name="checkpointer">The checkpointer used to do checkpoints.</param>
private void Checkpoint(Checkpointer checkpointer)
{
Console.Error.WriteLine("Checkpointing shard " + _kinesisShardId);
// You can optionally provide an error handling delegate to be invoked when checkpointing fails.
// The library comes with a default implementation that retries for a number of times with a fixed
// delay between each attempt. If you do not provide an error handler, the checkpointing operation
// will not be retried, but processing will continue.
checkpointer.Checkpoint(RetryingCheckpointErrorHandler.Create(NumRetries, Backoff));
}
public async Task TestCommitWithRemaining(IMessage[] successful, IMessage[] remaining)
{
var store = new Mock <ICheckpointStore>();
store.Setup(d => d.GetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(-1));
ICheckpointer checkpointer = await Checkpointer.CreateAsync("id1", store.Object);
await checkpointer.CommitAsync(successful, remaining, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None);
Assert.True(remaining.All(m => checkpointer.Admit(m)));
}
public async Task TestConstructor()
{
var store = new Mock <ICheckpointStore>();
store.Setup(d => d.GetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(10));
await Assert.ThrowsAsync <ArgumentNullException>(() => Checkpointer.CreateAsync(null, store.Object));
await Assert.ThrowsAsync <ArgumentNullException>(() => Checkpointer.CreateAsync("id", null));
await Assert.ThrowsAsync <ArgumentNullException>(() => Checkpointer.CreateAsync(null, null));
}
public async Task TestAdmit(Message message, long offset, bool expected)
{
var store = new Mock <ICheckpointStore>();
store.Setup(d => d.GetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(offset));
using (ICheckpointer checkpointer = await Checkpointer.CreateAsync("id1", store.Object))
{
bool result = checkpointer.Admit(message);
Assert.Equal(expected, result);
await checkpointer.CloseAsync(CancellationToken.None);
}
}
public async Task TestCommitMultiple()
{
var store = new Mock <ICheckpointStore>();
store.Setup(d => d.GetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(10));
using (ICheckpointer checkpointer1 = await Checkpointer.CreateAsync("id1", store.Object))
{
IMessage[] tocheckpoint = new[] { MessageWithOffset(13), MessageWithOffset(12), MessageWithOffset(11), MessageWithOffset(10), MessageWithOffset(9) };
await checkpointer1.CommitAsync(tocheckpoint, new IMessage[] { }, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None);
Assert.Equal(13, checkpointer1.Offset);
await checkpointer1.CloseAsync(CancellationToken.None);
}
}
public async Task TestCancellation()
{
var store = new Mock <ICheckpointStore>();
store.Setup(d => d.GetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new CheckpointData(10));
using (var cts = new CancellationTokenSource())
using (ICheckpointer checkpointer1 = await Checkpointer.CreateAsync("id1", store.Object))
{
var tcs = new TaskCompletionSource <bool>();
cts.Token.Register(() => tcs.SetCanceled());
store.Setup(d => d.SetCheckpointDataAsync(It.IsAny <string>(), It.IsAny <CheckpointData>(), It.IsAny <CancellationToken>())).Returns(tcs.Task);
Task result = checkpointer1.CommitAsync(new[] { MessageWithOffset(20) }, new IMessage[] { }, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None);
cts.Cancel();
await Assert.ThrowsAsync <TaskCanceledException>(() => result);
Assert.Equal(20, checkpointer1.Offset);
await checkpointer1.CloseAsync(CancellationToken.None);
}
}
internal DefaultKclProcess(IShardRecordProcessor processor, IoHandler iohandler)
{
_processor = processor;
_iohandler = iohandler;
_checkpointer = new InternalCheckpointer(this);
}
public DefaultShutdownRequestedInput(Checkpointer checkpointer)
{
Checkpointer = checkpointer;
}
public DefaultShutdownInput(ShutdownReason reason, Checkpointer checkpointer)
{
Reason = reason;
Checkpointer = checkpointer;
}
public DefaultShutdownInput(ShutdownReason reason, Checkpointer checkpointer)
{
_reason = reason;
_checkpointer = checkpointer;
}
public DefaultShardEndedInput(Checkpointer checkpointer)
{
Checkpointer = checkpointer;
}
