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 TestAdmit()
{
var store = new NullCheckpointStore(14);
MasterCheckpointer master = await MasterCheckpointer.CreateAsync("checkpointer", store);
Assert.Equal(false, master.Admit(MessageWithOffset(10)));
Assert.Equal(true, master.Admit(MessageWithOffset(15)));
}
public async Task TestNoChildren()
{
var store = new NullCheckpointStore();
MasterCheckpointer master = await MasterCheckpointer.CreateAsync("checkpointer", store);
Assert.Equal(Checkpointer.InvalidOffset, master.Offset);
await master.CommitAsync(new [] { MessageWithOffset(3), MessageWithOffset(1) }, new [] { MessageWithOffset(2) }, Option.None <DateTime>(), Option.None <DateTime>(), CancellationToken.None);
Assert.Equal(1, master.Offset);
}
public static async Task <Dispatcher> CreateAsync(string id, string iotHubName, IDictionary <Endpoint, IList <uint> > endpointsWithPriorities, IEndpointExecutorFactory factory)
{
Preconditions.CheckNotNull(id);
Preconditions.CheckNotNull(endpointsWithPriorities);
Preconditions.CheckNotNull(factory);
var masterCheckpointer = await MasterCheckpointer.CreateAsync(id, NullCheckpointStore.Instance);
IEnumerable <Task <IEndpointExecutor> > tasks = endpointsWithPriorities.Select(e => factory.CreateAsync(e.Key, e.Value));
IEndpointExecutor[] executors = await Task.WhenAll(tasks);
return(new Dispatcher(id, iotHubName, executors, factory, masterCheckpointer));
}
Dispatcher(string id, string iotHubName, IEnumerable <IEndpointExecutor> execs, IEndpointExecutorFactory endpointExecutorFactory, MasterCheckpointer masterCheckpointer)
{
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.masterCheckpointer = Preconditions.CheckNotNull(masterCheckpointer);
ImmutableDictionary <string, IEndpointExecutor> execsDict = Preconditions.CheckNotNull(execs)
.ToImmutableDictionary(key => key.Endpoint.Id, value => value);
this.executors = new AtomicReference <ImmutableDictionary <string, IEndpointExecutor> >(execsDict);
}
public static async Task <Dispatcher> CreateAsync(string id, string iotHubName, ISet <Endpoint> endpoints, IEndpointExecutorFactory factory, ICheckpointStore checkpointStore)
{
Preconditions.CheckNotNull(id);
Preconditions.CheckNotNull(endpoints);
Preconditions.CheckNotNull(factory);
Preconditions.CheckNotNull(checkpointStore);
MasterCheckpointer masterCheckpointer = await MasterCheckpointer.CreateAsync(id, checkpointStore);
var executorFactory = new CheckpointerEndpointExecutorFactory(id, factory, masterCheckpointer);
IEnumerable <Task <IEndpointExecutor> > tasks = endpoints.Select(endpoint => executorFactory.CreateAsync(endpoint));
IEndpointExecutor[] executors = await Task.WhenAll(tasks);
return(new Dispatcher(id, iotHubName, executors, executorFactory, masterCheckpointer));
}
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);
}
