public TestSubscription(MiniClusterNode node, int expectedEvents, string streamId, CountdownEvent subscriptionsConfirmed)
{
Node = node;
SubscriptionsConfirmed = subscriptionsConfirmed;
EventAppeared = new CountdownEvent(expectedEvents);
StreamId = streamId;
}
private MiniClusterNode <TLogFormat, TStreamId> CreateNode(int index, Endpoints endpoints, EndPoint[] gossipSeeds)
{
_projections[index] = new ProjectionsSubsystem(new ProjectionSubsystemOptions(1, ProjectionType.All, false, TimeSpan.FromMinutes(Opts.ProjectionsQueryExpiryDefault), Opts.FaultOutOfOrderProjectionsDefault, 500, 250));
var node = new MiniClusterNode <TLogFormat, TStreamId>(
PathName, index, endpoints.InternalTcp,
endpoints.ExternalTcp, endpoints.HttpEndPoint,
subsystems: new ISubsystem[] { _projections[index] }, gossipSeeds: gossipSeeds);
return(node);
}
private MiniClusterNode CreateNode(int index, Endpoints endpoints, IPEndPoint[] gossipSeeds)
{
_projections = new ProjectionsSubsystem(1, runProjections: ProjectionType.All, startStandardProjections: false);
var node = new MiniClusterNode(
PathName, index, endpoints.InternalTcp, endpoints.InternalTcpSec, endpoints.InternalHttp, endpoints.ExternalTcp,
endpoints.ExternalTcpSec, endpoints.ExternalHttp, skipInitializeStandardUsersCheck: false,
subsystems: new ISubsystem[] { _projections }, gossipSeeds: gossipSeeds);
WaitIdle();
return node;
}
protected virtual MiniClusterNode CreateNode(int index, Endpoints endpoints, IPEndPoint[] gossipSeeds,
bool wait = true)
{
var node = new MiniClusterNode(
PathName, index, endpoints.InternalTcp, endpoints.InternalTcpSec, endpoints.InternalHttp,
endpoints.ExternalTcp,
endpoints.ExternalTcpSec, endpoints.ExternalHttp, skipInitializeStandardUsersCheck: false,
subsystems: new ISubsystem[] { }, gossipSeeds: gossipSeeds, inMemDb: false);
return(node);
}
private MiniClusterNode CreateNode(int index, Endpoints endpoints, IPEndPoint[] gossipSeeds)
{
_projections = new ProjectionsSubsystem(1, runProjections: ProjectionType.All,
startStandardProjections: false, projectionQueryExpiry: TimeSpan.FromMinutes(Opts.ProjectionsQueryExpiryDefault),
faultOutOfOrderProjections: Opts.FaultOutOfOrderProjectionsDefault);
var node = new MiniClusterNode(
PathName, index, endpoints.InternalTcp, endpoints.InternalTcpSec, endpoints.InternalHttp, endpoints.ExternalTcp,
endpoints.ExternalTcpSec, endpoints.ExternalHttp, skipInitializeStandardUsersCheck: false,
subsystems: new ISubsystem[] { _projections }, gossipSeeds: gossipSeeds);
WaitIdle();
return(node);
}
private MiniClusterNode CreateNode(int index, Endpoints endpoints, EndPoint[] gossipSeeds)
{
_projections[index] = new ProjectionsSubsystem(1, runProjections: ProjectionType.All,
startStandardProjections: false,
projectionQueryExpiry: TimeSpan.FromMinutes(Opts.ProjectionsQueryExpiryDefault),
faultOutOfOrderProjections: Opts.FaultOutOfOrderProjectionsDefault);
var node = new MiniClusterNode(
PathName, index, endpoints.InternalTcp,
endpoints.ExternalTcp, endpoints.HttpEndPoint,
subsystems: new ISubsystem[] { _projections[index] }, gossipSeeds: gossipSeeds);
return(node);
}
protected override MiniClusterNode CreateNode(int index, Endpoints endpoints, EndPoint[] gossipSeeds,
bool wait = true)
{
var isReadOnly = index == 2;
var node = new MiniClusterNode(
PathName, index, endpoints.InternalTcp,
endpoints.ExternalTcp, endpoints.HttpEndPoint, gossipSeeds, inMemDb: false,
readOnlyReplica: isReadOnly);
if (wait && !isReadOnly)
{
WaitIdle();
}
return(node);
}
private async Task AddStreamAndWait(MiniClusterNode <TLogFormat, TStreamId> leader,
MiniClusterNode <TLogFormat, TStreamId> follower, string streamName)
{
var leaderIndex = leader.Db.Config.IndexCheckpoint.Read();
var response = await PostEvent(_followerEndPoint, $"streams/{streamName}", requireLeader : false);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
AssertEx.IsOrBecomesTrue(() => leader.Db.Config.IndexCheckpoint.Read() > leaderIndex,
timeout: TimeSpan.FromSeconds(10),
msg: "Waiting for event to be processed on leader timed out!");
leaderIndex = leader.Db.Config.IndexCheckpoint.Read();
AssertEx.IsOrBecomesTrue(() => follower.Db.Config.IndexCheckpoint.Read() >= leaderIndex,
timeout: TimeSpan.FromSeconds(10),
msg: $"Waiting for event to be synced with follower timed out! ({leaderIndex})");
}
public static ClientMessage.WriteEventsCompleted WriteEvent(MiniClusterNode node, Event[] events, string streamId)
{
var resetEvent = new ManualResetEventSlim();
ClientMessage.WriteEventsCompleted writeResult = null;
node.Node.MainQueue.Publish(new ClientMessage.WriteEvents(Guid.NewGuid(), Guid.NewGuid(),
new CallbackEnvelope(msg =>
{
writeResult = (ClientMessage.WriteEventsCompleted)msg;
resetEvent.Set();
}), false, streamId, -1, events,
SystemAccount.Principal, SystemUsers.Admin, SystemUsers.DefaultAdminPassword));
if (!resetEvent.Wait(_timeout))
{
Assert.Fail("Timed out waiting for event to be written");
return(null);
}
return(writeResult);
}
public static ClientMessage.ReadEventCompleted ReadEvent(MiniClusterNode node, string streamId, long eventNumber)
{
ClientMessage.ReadEventCompleted readResult = null;
var resetEvent = new ManualResetEventSlim();
var read = new ClientMessage.ReadEvent(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(msg =>
{
readResult = (ClientMessage.ReadEventCompleted)msg;
resetEvent.Set();
}), streamId, eventNumber,
false, false, SystemAccount.Principal);
node.Node.MainQueue.Publish(read);
if (!resetEvent.Wait(_timeout))
{
Assert.Fail("Timed out waiting for the event to be read");
return(null);
}
return(readResult);
}
protected override async Task Given()
{
_expectedNumberOfRoleAssignments.Wait(5000);
_liveNode = GetLeader();
Assert.IsNotNull(_liveNode, "Could not get leader node");
var events = new Event[] { new Event(Guid.NewGuid(), "test-type", false, new byte[10], new byte[0]) };
var writeResult = ReplicationTestHelper.WriteEvent(_liveNode, events, _streamId);
Assert.AreEqual(OperationResult.Success, writeResult.Result);
_commitPosition = writeResult.CommitPosition;
var followers = GetFollowers();
foreach (var s in followers)
{
await ShutdownNode(s.DebugIndex);
}
await base.Given();
}
public static ClientMessage.ReadStreamEventsBackwardCompleted ReadStreamEventsBackward <TLogFormat, TStreamId>(
MiniClusterNode <TLogFormat, TStreamId> node,
string streamId)
{
ClientMessage.ReadStreamEventsBackwardCompleted readResult = null;
var resetEvent = new ManualResetEventSlim();
var read = new ClientMessage.ReadStreamEventsBackward(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(
msg => {
readResult = (ClientMessage.ReadStreamEventsBackwardCompleted)msg;
resetEvent.Set();
}), streamId, 9, 10,
false, false, null, SystemAccounts.System);
node.Node.MainQueue.Publish(read);
if (!resetEvent.Wait(_timeout))
{
Assert.Fail("Timed out waiting for the stream to be read backward");
return(null);
}
return(readResult);
}
public static ClientMessage.ReadAllEventsBackwardCompleted ReadAllEventsBackward <TLogFormat, TStreamId>(
MiniClusterNode <TLogFormat, TStreamId> node,
long position)
{
ClientMessage.ReadAllEventsBackwardCompleted readResult = null;
var resetEvent = new ManualResetEventSlim();
var done = false;
while (!done)
{
resetEvent.Reset();
var read = new ClientMessage.ReadAllEventsBackward(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(
msg => {
readResult = (ClientMessage.ReadAllEventsBackwardCompleted)msg;
resetEvent.Set();
}),
-1, -1, 100, false, false, null, SystemAccounts.System);
node.Node.MainQueue.Publish(read);
if (!resetEvent.Wait(_timeout))
{
Assert.Fail("Timed out waiting for events to be read backward");
return(null);
}
if (readResult.Result == ReadAllResult.Error)
{
Assert.Fail("Failed to read backwards. Read result error: {0}", readResult.Error);
return(null);
}
done = readResult.NextPos.CommitPosition < position;
}
return(readResult);
}
