public async Task Invoke(IMessage message, uint priority, uint timeToLiveSecs)
{
try
{
if (this.closed)
{
throw new InvalidOperationException($"Endpoint executor for endpoint {this.Endpoint} is closed.");
}
using (MetricsV0.StoreLatency(this.Endpoint.Id))
{
// Get the checkpointer corresponding to the queue for this priority
SortedDictionary <uint, EndpointExecutorFsm> snapshot = this.prioritiesToFsms;
ICheckpointer checkpointer = snapshot[priority].Checkpointer;
IMessage storedMessage = await this.messageStore.Add(GetMessageQueueId(this.Endpoint.Id, priority), message);
checkpointer.Propose(storedMessage);
Events.AddMessageSuccess(this, storedMessage.Offset, priority, timeToLiveSecs);
}
this.hasMessagesInQueue.Set();
MetricsV0.StoredCountIncrement(this.Endpoint.Id, priority);
}
catch (Exception ex)
{
Events.AddMessageFailure(this, ex);
throw;
}
}
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);
}
}
async Task AddChild(ICheckpointer checkpointer)
{
using (await this.sync.LockAsync())
{
this.childCheckpointers.Value = this.ChildCheckpointers.SetItem(checkpointer.Id, checkpointer);
}
}
public async Task SmokeTest()
{
var store = new NullCheckpointStore();
using (MasterCheckpointer master = await MasterCheckpointer.CreateAsync("checkpointer", store))
{
ICheckpointer checkpointer1 = await master.CreateAsync("endpoint1");
ICheckpointer checkpointer2 = await master.CreateAsync("endpoint2");
Assert.Equal(Checkpointer.InvalidOffset, master.Offset);
Assert.Equal(Checkpointer.InvalidOffset, checkpointer1.Offset);
Assert.Equal(Checkpointer.InvalidOffset, checkpointer2.Offset);
Assert.False(checkpointer1.HasOutstanding);
Assert.False(checkpointer2.HasOutstanding);
checkpointer1.Propose(MessageWithOffset(1));
Assert.Equal(Checkpointer.InvalidOffset, master.Offset);
Assert.Equal(Checkpointer.InvalidOffset, checkpointer1.Offset);
Assert.Equal(Checkpointer.InvalidOffset, checkpointer2.Offset);
Assert.True(checkpointer1.HasOutstanding);
Assert.False(checkpointer2.HasOutstanding);
await checkpointer1.CommitAsync(new[] { MessageWithOffset(1) }, new IMessage[] { }, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None);
Assert.Equal(1, master.Offset);
Assert.Equal(1, checkpointer1.Offset);
Assert.Equal(Checkpointer.InvalidOffset, checkpointer2.Offset);
Assert.False(checkpointer1.HasOutstanding);
Assert.False(checkpointer2.HasOutstanding);
await master.CloseAsync(CancellationToken.None);
}
}
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.Equal(false, result);
}
}
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 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 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 Invoke(IMessage message, uint priority, uint timeToLiveSecs)
{
try
{
if (this.closed)
{
throw new InvalidOperationException($"Endpoint executor for endpoint {this.Endpoint} is closed.");
}
// Get the checkpointer corresponding to the queue for this priority
ImmutableDictionary <uint, EndpointExecutorFsm> snapshot = this.prioritiesToFsms;
ICheckpointer checkpointer = snapshot[priority].Checkpointer;
IMessage storedMessage = await this.messageStore.Add(MessageQueueIdHelper.GetMessageQueueId(this.Endpoint.Id, priority), message, timeToLiveSecs);
checkpointer.Propose(storedMessage);
Events.AddMessageSuccess(this, storedMessage.Offset, priority, timeToLiveSecs);
this.hasMessagesInQueue.Set();
}
catch (Exception ex)
{
Routing.UserMetricLogger.LogIngressFailureMetric(1, this.Endpoint.IotHubName, message, "storage_failure");
Events.AddMessageFailure(this, ex);
throw;
}
}
public async Task <IEndpointExecutor> CreateAsync(Endpoint endpoint, ICheckpointer checkpointer, EndpointExecutorConfig endpointExecutorConfig)
{
IEndpointExecutor exec = await this.underlying.CreateAsync(endpoint, checkpointer, endpointExecutorConfig);
await exec.CloseAsync();
return(exec);
}
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);
}
public async Task <IEndpointExecutor> CreateAsync(Endpoint endpoint, IList <uint> _, ICheckpointerFactory checkpointerFactory, EndpointExecutorConfig endpointExecutorConfig)
{
ICheckpointer checkpointer = await checkpointerFactory.CreateAsync(endpoint.Id);
IEndpointExecutor executor = new AsyncEndpointExecutor(endpoint, checkpointer, endpointExecutorConfig, this.options);
return(executor);
}
public EventProcessor(EventHubOptions options, ITriggeredFunctionExecutor executor, ILogger logger, bool singleDispatch, ICheckpointer checkpointer = null)
{
_checkpointer = checkpointer ?? this;
_executor = executor;
_singleDispatch = singleDispatch;
_batchCheckpointFrequency = options.BatchCheckpointFrequency;
_logger = logger;
}
public async Task <IEndpointExecutor> CreateAsync(Endpoint endpoint)
{
string id = RoutingIdBuilder.Parse(this.idPrefix).Map(prefixTemplate => new RoutingIdBuilder(prefixTemplate.IotHubName, prefixTemplate.RouterNumber, Option.Some(endpoint.Id)).GetId()).GetOrElse(endpoint.Id);
ICheckpointer checkpointer = await this.checkpointerFactory.CreateAsync(id);
IEndpointExecutor executor = await this.executorFactory.CreateAsync(endpoint, checkpointer);
return(executor);
}
public SyncEndpointExecutor(Endpoint endpoint, ICheckpointer checkpointer, EndpointExecutorConfig config)
{
Preconditions.CheckNotNull(endpoint);
Preconditions.CheckNotNull(config);
this.checkpointer = Preconditions.CheckNotNull(checkpointer);
this.machine = new EndpointExecutorFsm(endpoint, checkpointer, config);
this.cts = new CancellationTokenSource();
this.closed = new AtomicBoolean();
this.sync = new AsyncLock();
}
public Task <IEndpointExecutor> CreateAsync(Endpoint endpoint, ICheckpointer checkpointer, EndpointExecutorConfig endpointExecutorConfig)
{
Preconditions.CheckNotNull(endpoint, nameof(endpoint));
Preconditions.CheckNotNull(checkpointer, nameof(checkpointer));
Preconditions.CheckNotNull(endpointExecutorConfig, nameof(endpointExecutorConfig));
this.messageStore.AddEndpoint(endpoint.Id);
IEndpointExecutor endpointExecutor = new StoringAsyncEndpointExecutor(endpoint, checkpointer, endpointExecutorConfig, this.options, this.messageStore);
return(Task.FromResult(endpointExecutor));
}
public async Task UpdatePriorities(IList <uint> priorities, Option <Endpoint> newEndpoint)
{
Preconditions.CheckArgument(priorities.Count > 0);
Events.UpdatePriorities(this, priorities);
if (this.closed)
{
throw new InvalidOperationException($"Endpoint executor for endpoint {this.Endpoint} is closed.");
}
// Update priorities by merging the new ones with the existing.
// We don't ever remove stale priorities, otherwise stored messages
// pending for a removed priority will never get sent.
ImmutableDictionary <uint, EndpointExecutorFsm> snapshot = this.prioritiesToFsms;
Dictionary <uint, EndpointExecutorFsm> updatedSnapshot = new Dictionary <uint, EndpointExecutorFsm>(snapshot);
foreach (uint priority in priorities)
{
if (!updatedSnapshot.ContainsKey(priority))
{
string id = GetMessageQueueId(this.Endpoint.Id, priority);
// Create a message queue in the store for every priority we have
await this.messageStore.AddEndpoint(id);
// Create a checkpointer and a FSM for every message queue
ICheckpointer checkpointer = await this.checkpointerFactory.CreateAsync(id, this.Endpoint.Id, priority);
EndpointExecutorFsm fsm = new EndpointExecutorFsm(this.Endpoint, checkpointer, this.config);
// Add it to our dictionary
updatedSnapshot.Add(priority, fsm);
}
else
{
// Update the existing FSM with the new endpoint
EndpointExecutorFsm fsm = updatedSnapshot[priority];
await newEndpoint.ForEachAsync(e => fsm.RunAsync(Commands.UpdateEndpoint(e)));
}
}
if (this.prioritiesToFsms.CompareAndSet(snapshot, updatedSnapshot.ToImmutableDictionary()))
{
Events.UpdatePrioritiesSuccess(this, updatedSnapshot.Keys.ToList());
// Update the lastUsedFsm to be the initial one, we always
// have at least one priority->FSM pair at this point.
this.lastUsedFsm = updatedSnapshot[priorities[0]];
}
else
{
Events.UpdatePrioritiesFailure(this, updatedSnapshot.Keys.ToList());
}
}
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)));
}
/// <summary>
/// Creates a new connection with an Azure Event Hub
/// </summary>
public AzureEventHub(
string eventHubConnectionString,
string eventHubEntity,
ICheckpointer checkpointer)
{
_readers = new List <AzureEventHubReader>();
_client = EventHubClient.CreateFromConnectionString(
new EventHubsConnectionStringBuilder(eventHubConnectionString)
{
EntityPath = eventHubEntity
}.ToString());
_checkpointer = checkpointer;
}
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 StoringAsyncEndpointExecutor(Endpoint endpoint,
ICheckpointer checkpointer,
EndpointExecutorConfig config,
AsyncEndpointExecutorOptions options,
IMessageStore messageStore)
{
Preconditions.CheckNotNull(endpoint);
Preconditions.CheckNotNull(config);
this.checkpointer = Preconditions.CheckNotNull(checkpointer);
this.options = Preconditions.CheckNotNull(options);
this.machine = new EndpointExecutorFsm(endpoint, checkpointer, config);
this.messageStore = messageStore;
this.sendMessageTask = Task.Run(this.SendMessagesPump);
}
Dispatcher(string id, string iotHubName, IEnumerable <IEndpointExecutor> execs, IEndpointExecutorFactory endpointExecutorFactory, ICheckpointer checkpointer)
{
this.Id = Preconditions.CheckNotNull(id);
this.iotHubName = Preconditions.CheckNotNull(iotHubName);
this.endpointExecutorFactory = Preconditions.CheckNotNull(endpointExecutorFactory);
this.closed = new AtomicBoolean(false);
this.cts = new CancellationTokenSource();
this.checkpointer = Preconditions.CheckNotNull(checkpointer);
ImmutableDictionary <string, IEndpointExecutor> execsDict = Preconditions.CheckNotNull(execs)
.ToImmutableDictionary(key => key.Endpoint.Id, value => value);
this.executors = new AtomicReference <ImmutableDictionary <string, IEndpointExecutor> >(execsDict);
}
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 StoringAsyncEndpointExecutor(
Endpoint endpoint,
IList <uint> priorities,
ICheckpointer checkpointer,
EndpointExecutorConfig config,
AsyncEndpointExecutorOptions options,
IMessageStore messageStore)
{
Preconditions.CheckNotNull(endpoint);
Preconditions.CheckNotNull(config);
Preconditions.CheckNotNull(priorities);
Preconditions.CheckArgument(priorities.Count != 0);
this.checkpointer = Preconditions.CheckNotNull(checkpointer);
this.options = Preconditions.CheckNotNull(options);
this.machine = new EndpointExecutorFsm(endpoint, checkpointer, config);
this.messageStore = messageStore;
this.sendMessageTask = Task.Run(this.SendMessagesPump);
this.UpdatePriorities(priorities);
}
public EndpointExecutorFsm(Endpoint endpoint, ICheckpointer checkpointer, EndpointExecutorConfig config, ISystemTime systemTime)
{
this.processor = Preconditions.CheckNotNull(endpoint).CreateProcessor();
this.Checkpointer = Preconditions.CheckNotNull(checkpointer);
this.config = Preconditions.CheckNotNull(config);
this.systemTime = Preconditions.CheckNotNull(systemTime);
this.retryTimer = new Timer(this.RetryAsync, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
this.retryPeriod = Timeout.InfiniteTimeSpan;
this.lastFailedRevivalTime = checkpointer.LastFailedRevivalTime;
this.unhealthySince = checkpointer.UnhealthySince;
if (checkpointer.LastFailedRevivalTime.HasValue)
{
this.state = State.DeadIdle;
this.retryAttempts = short.MaxValue; // setting to some big value
}
else
{
this.state = State.Idle;
}
}
public AsyncEndpointExecutor(Endpoint endpoint, ICheckpointer checkpointer, EndpointExecutorConfig config, AsyncEndpointExecutorOptions options)
{
Preconditions.CheckNotNull(endpoint);
Preconditions.CheckNotNull(config);
this.checkpointer = Preconditions.CheckNotNull(checkpointer);
this.cts = new CancellationTokenSource();
this.options = Preconditions.CheckNotNull(options);
this.machine = new EndpointExecutorFsm(endpoint, checkpointer, config);
this.closed = new AtomicBoolean();
// The three size variables below adjust the following parameters:
// 1. MaxMessagesPerTask - the maximum number of messages the batch block will process before yielding
// 2. BoundedCapacity - the size of the batch blocks input buffer
// 3. BatchBlock ctor - the maximum size of each batch emitted by the block (can be smaller because of the timer)
var batchOptions = new GroupingDataflowBlockOptions
{
MaxMessagesPerTask = MaxMessagesPerTask,
BoundedCapacity = options.BatchSize
};
var batchBlock = new BatchBlock <IMessage>(options.BatchSize, batchOptions);
this.batchTimer = new Timer(Trigger, batchBlock, options.BatchTimeout, options.BatchTimeout);
var processOptions = new ExecutionDataflowBlockOptions
{
BoundedCapacity = 1
};
var process = new ActionBlock <IMessage[]>(this.MessagesAction, processOptions);
var linkOptions = new DataflowLinkOptions {
PropagateCompletion = true
};
batchBlock.LinkTo(process, linkOptions);
this.head = batchBlock;
this.tail = process;
}
public async Task TestOutstanding()
{
var store = new NullCheckpointStore(1L);
MasterCheckpointer master = await MasterCheckpointer.CreateAsync("checkpointer", store);
ICheckpointer checkpointer1 = await master.CreateAsync("endpoint1");
// Propose two messages
IMessage message1 = MessageWithOffset(2);
IMessage message2 = MessageWithOffset(3);
checkpointer1.Propose(message2);
checkpointer1.Propose(message1);
Assert.Equal(3L, checkpointer1.Proposed);
Assert.Equal(1L, master.Offset);
// Commit the first message
await checkpointer1.CommitAsync(new[] { message1 }, new IMessage[] {}, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None);
// Ensure the master represents the checkpointed message offset
Assert.True(checkpointer1.HasOutstanding);
Assert.Equal(2L, master.Offset);
}
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);
}
}
public Task <IEndpointExecutor> CreateAsync(Endpoint endpoint, IList <uint> _, ICheckpointer checkpointer, EndpointExecutorConfig endpointExecutorConfig)
{
IEndpointExecutor executor = new SyncEndpointExecutor(endpoint, checkpointer, endpointExecutorConfig);
return(Task.FromResult(executor));
}
public LoggedCheckpointer(ICheckpointer underlying)
{
this.underlying = underlying;
this.Processed = new List <IMessage>();
}
