/// <summary>
/// Sets up the supporting infrastructure and communication hooks for our state machines. This is here to support
/// an external requirement for assembling protocol servers given an existing set of state machines (used to prove
/// correctness).
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("rawtypes") public ProtocolServer constructSupportingInfrastructureFor(InstanceId me, org.neo4j.cluster.com.message.MessageSource input, org.neo4j.cluster.com.message.MessageSender output, DelayedDirectExecutor executor, org.neo4j.cluster.timeout.Timeouts timeouts, java.util.concurrent.Executor stateMachineExecutor, final org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.context.MultiPaxosContext context, org.neo4j.cluster.statemachine.StateMachine[] machines)
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
public virtual ProtocolServer ConstructSupportingInfrastructureFor(InstanceId me, MessageSource input, MessageSender output, DelayedDirectExecutor executor, Timeouts timeouts, Executor stateMachineExecutor, MultiPaxosContext context, StateMachine[] machines)
{
StateMachines stateMachines = new StateMachines(_logging, _stateMachinesMonitor, input, output, timeouts, executor, stateMachineExecutor, me);
foreach (StateMachine machine in machines)
{
stateMachines.AddStateMachine(machine);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ProtocolServer server = new ProtocolServer(me, stateMachines, logging);
ProtocolServer server = new ProtocolServer(me, stateMachines, _logging);
server.AddBindingListener(me1 => context.ClusterContext.setBoundAt(me1));
stateMachines.AddMessageProcessor(new HeartbeatRefreshProcessor(stateMachines.Outgoing, context.ClusterContext));
input.AddMessageProcessor(new HeartbeatIAmAliveProcessor(stateMachines.Outgoing, context.ClusterContext));
Cluster cluster = server.NewClient(typeof(Cluster));
cluster.AddClusterListener(new HeartbeatJoinListener(stateMachines.Outgoing));
cluster.AddClusterListener(new HeartbeatLeftListener(context.HeartbeatContext, _logging));
context.HeartbeatContext.addHeartbeatListener(new HeartbeatReelectionListener(server.NewClient(typeof(Election)), _logging));
context.ClusterContext.addClusterListener(new ClusterLeaveReelectionListener(server.NewClient(typeof(Election)), _logging));
StateMachineRules rules = (new StateMachineRules(stateMachines.Outgoing)).rule(ClusterState.start, ClusterMessage.create, ClusterState.entered, @internal(AtomicBroadcastMessage.entered), @internal(ProposerMessage.join), @internal(AcceptorMessage.join), @internal(LearnerMessage.join), @internal(HeartbeatMessage.join), @internal(ElectionMessage.created), @internal(SnapshotMessage.join)).rule(ClusterState.discovery, ClusterMessage.configurationResponse, ClusterState.joining, @internal(AcceptorMessage.join), @internal(LearnerMessage.join), @internal(AtomicBroadcastMessage.join)).rule(ClusterState.discovery, ClusterMessage.configurationResponse, ClusterState.entered, @internal(AtomicBroadcastMessage.entered), @internal(ProposerMessage.join), @internal(AcceptorMessage.join), @internal(LearnerMessage.join), @internal(HeartbeatMessage.join), @internal(ElectionMessage.join), @internal(SnapshotMessage.join)).rule(ClusterState.joining, ClusterMessage.configurationChanged, ClusterState.entered, @internal(AtomicBroadcastMessage.entered), @internal(ProposerMessage.join), @internal(AcceptorMessage.join), @internal(LearnerMessage.join), @internal(HeartbeatMessage.join), @internal(ElectionMessage.join), @internal(SnapshotMessage.join)).rule(ClusterState.joining, ClusterMessage.joinFailure, ClusterState.start, @internal(AtomicBroadcastMessage.leave), @internal(AcceptorMessage.leave), @internal(LearnerMessage.leave), @internal(ProposerMessage.leave)).rule(ClusterState.entered, ClusterMessage.leave, ClusterState.start, @internal(AtomicBroadcastMessage.leave), @internal(AcceptorMessage.leave), @internal(LearnerMessage.leave), @internal(HeartbeatMessage.leave), @internal(SnapshotMessage.leave), @internal(ElectionMessage.leave), @internal(ProposerMessage.leave)).rule(ClusterState.entered, ClusterMessage.leave, ClusterState.start, @internal(AtomicBroadcastMessage.leave), @internal(AcceptorMessage.leave), @internal(LearnerMessage.leave), @internal(HeartbeatMessage.leave), @internal(ElectionMessage.leave), @internal(SnapshotMessage.leave), @internal(ProposerMessage.leave)).rule(ClusterState.leaving, ClusterMessage.configurationChanged, ClusterState.start, @internal(AtomicBroadcastMessage.leave), @internal(AcceptorMessage.leave), @internal(LearnerMessage.leave), @internal(HeartbeatMessage.leave), @internal(ElectionMessage.leave), @internal(SnapshotMessage.leave), @internal(ProposerMessage.leave)).rule(ClusterState.leaving, ClusterMessage.leaveTimedout, ClusterState.start, @internal(AtomicBroadcastMessage.leave), @internal(AcceptorMessage.leave), @internal(LearnerMessage.leave), @internal(HeartbeatMessage.leave), @internal(ElectionMessage.leave), @internal(SnapshotMessage.leave), @internal(ProposerMessage.leave));
stateMachines.AddStateTransitionListener(rules);
return(server);
}
public ProtocolServer(InstanceId me, StateMachines stateMachines, LogProvider logProvider)
{
this._me = me;
this.StateMachinesConflict = stateMachines;
this._msgLog = logProvider.getLog(this.GetType());
StateMachineConversations conversations = new StateMachineConversations(me);
ProxyFactory = new StateMachineProxyFactory(stateMachines, conversations, me, logProvider);
stateMachines.AddMessageProcessor(ProxyFactory);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAlwaysAddItsInstanceIdToOutgoingMessages()
public virtual void ShouldAlwaysAddItsInstanceIdToOutgoingMessages()
{
InstanceId me = new InstanceId(42);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<org.neo4j.cluster.com.message.Message> sentOut = new java.util.LinkedList<>();
IList <Message> sentOut = new LinkedList <Message>();
/*
* Lots of setup required. Must have a sender that keeps messages so we can see what the machine sent out.
* We must have the StateMachines actually delegate the incoming message and retrieve the generated outgoing.
* That means we need an actual StateMachine with a registered MessageType. And most of those are void
* methods, which means lots of Answer objects.
*/
// Given
MessageSender sender = mock(typeof(MessageSender));
// The sender, which adds messages outgoing to the list above.
doAnswer(invocation =>
{
((IList <Org.Neo4j.cluster.com.message.Message>)sentOut).AddRange(invocation.getArgument(0));
return(null);
}).when(sender).process(ArgumentMatchers.any <IList <Message <? extends MessageType> > >());
StateMachines stateMachines = new StateMachines(NullLogProvider.Instance, mock(typeof(StateMachines.Monitor)), mock(typeof(MessageSource)), sender, mock(typeof(Timeouts)), mock(typeof(DelayedDirectExecutor)), ThreadStart.run, me);
// The state machine, which has a TestMessage message type and simply adds a HEADER_TO header to the messages it
// is handed to handle.
StateMachine machine = mock(typeof(StateMachine));
when(machine.MessageType).then((Answer <object>)invocation => typeof(TestMessage));
doAnswer(invocation =>
{
Message message = invocation.getArgument(0);
MessageHolder holder = invocation.getArgument(1);
message.setHeader(Message.HEADER_TO, "to://neverland");
holder.offer(message);
return(null);
}).when(machine).handle(any(typeof(Message)), any(typeof(MessageHolder)));
stateMachines.AddStateMachine(machine);
// When
stateMachines.Process(Message.@internal(TestMessage.Message1));
// Then
assertEquals("StateMachines should not make up messages from thin air", 1, sentOut.Count);
Message sent = sentOut[0];
assertTrue("StateMachines should add the instance-id header", sent.hasHeader(Message.HEADER_INSTANCE_ID));
assertEquals("StateMachines should add instance-id header that has the correct value", me.ToString(), sent.getHeader(Message.HEADER_INSTANCE_ID));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenMessageHandlingCausesNewMessagesThenEnsureCorrectOrder()
public virtual void WhenMessageHandlingCausesNewMessagesThenEnsureCorrectOrder()
{
// Given
StateMachines stateMachines = new StateMachines(NullLogProvider.Instance, mock(typeof(StateMachines.Monitor)), mock(typeof(MessageSource)), Mockito.mock(typeof(MessageSender)), Mockito.mock(typeof(Timeouts)), Mockito.mock(typeof(DelayedDirectExecutor)), ThreadStart.run, mock(typeof(InstanceId)));
List <TestMessage> handleOrder = new List <TestMessage>();
StateMachine stateMachine = new StateMachine(handleOrder, typeof(TestMessage), TestState.Test, NullLogProvider.Instance);
stateMachines.AddStateMachine(stateMachine);
// When
stateMachines.Process(@internal(TestMessage.Message1));
// Then
assertThat(handleOrder.ToString(), equalTo("[message1, message2, message4, message5, message3]"));
}
public OutgoingMessageHolder(StateMachines outerInstance)
{
this._outerInstance = outerInstance;
}
public RunnableAnonymousInnerClass(StateMachines outerInstance, Message <T1> message)
{
this.outerInstance = outerInstance;
this._message = message;
temporaryOutgoing = new OutgoingMessageHolder(outerInstance);
}
