public void DisposeAndStateDoesNotChangeAfterHartbeatTest()
{
var mocker = new AutoMocker();
var serverIdentifier = new ServerIdentifier();
mocker.Use(serverIdentifier);
var options = new RaftOptions();
options.Hartbeat.FromMilliseconds = 50;
options.Hartbeat.ToMilliseconds = 50;
var timer = new HartbeatTimer(options, mocker.Get<ILoggerFactory>(), serverIdentifier);
var state = ServerStateType.Leader;
var dispose = timer.Subscribe((s) =>
{
state = s;
});
dispose.Dispose();
Thread.Sleep(100);
Assert.Equal(ServerStateType.Leader, state);
}
public Candidate(ServerIdentifier serverIdentifier,
IElectionTimer electionTimer,
IObserver<RequestVoteMessage> requestVote,
IObservable<RequestVoteResultMessage> voteReply,
IVotingSystem votingSystem,
IElection election,
ILogReplication logReplication,
Nodes nodes,
ILoggerFactory loggerFactory,
RaftOptions options)
{
isDispose = false;
_electionTimer = electionTimer;
_requestVote = requestVote;
_voteReply = voteReply;
_votingSystem = votingSystem;
_serverIdentifier = serverIdentifier;
_election = election;
_options = options;
_logger = loggerFactory.CreateLogger(nameof(Candidate) + " " + serverIdentifier);
_election.CurrentTerm++;
_election.VotedFor = _serverIdentifier.Id;
_logReplication = logReplication;
_nodes = nodes;
if (_options.UseLogging)
_logger.LogInformation($"{nameof(ServerStateType.Candidate)}");
RequestElection();
}
public ServiceRegistry(ServerIdentifier serverIdentifier,
RaftOptions options,
IRaftClient raftClient)
{
_options = options;
_raftClient = raftClient;
_serverIdentifier = serverIdentifier;
_list = new ConcurrentDictionary<Node, DateTimeOffset>();
_self = new Node()
{
Identifier = _serverIdentifier,
Name = _options.ServiceName,
Address = _options.IpAddress.ToString()
};
}
public Follower(ILoggerFactory loggerFactory,
Nodes nodes,
RaftOptions options,
ServerIdentifier serverIdentifier)
{
isDispose = false;
_options = options;
_serverIdentifier = serverIdentifier;
nodes.Clear();
_logger = loggerFactory.CreateLogger(nameof(Follower) + " " + serverIdentifier);
if (_options.UseLogging)
_logger.LogInformation($"{nameof(ServerStateType.Follower)}");
}
public void SubscribeTest()
{
var mocker = new AutoMocker();
var serverIdentifier = new ServerIdentifier();
mocker.Use(serverIdentifier);
var options = new RaftOptions();
options.Hartbeat.FromMilliseconds = 0;
options.Hartbeat.ToMilliseconds = 0;
var timer = new HartbeatTimer(options, mocker.Get<ILoggerFactory>(), serverIdentifier);
var state = ServerStateType.Leader;
timer.Subscribe((s) =>
{
state = s;
});
Thread.Sleep(100);
Assert.Equal(ServerStateType.Candidate, state);
}
public Leader(IElection election,
IHartbeatTimer hartbeat,
IObservable<AppendEntryResultMessage> reply,
IObserver<AppendEntryMessage> append,
IObserver<ClientResultMessage> clientReply,
IObservable<ClientMessage> client,
ILogReplication logReplication,
Nodes nodes,
ILoggerFactory loggerFactory,
RaftOptions options,
ServerIdentifier serverIdentifier)
{
_isDispose = false;
_hartbeat = hartbeat;
_append = append;
_clientReply = clientReply;
_client = client;
_logReplication = logReplication;
_nodes = nodes;
_options = options;
_serverIdentifier = serverIdentifier;
_election = election;
_logger = loggerFactory.CreateLogger(nameof(Leader) + " " + serverIdentifier);
if (_options.UseLogging)
_logger.LogInformation($"{nameof(ServerStateType.Leader)}");
// Reinitialized after election
NextIndex = new ConcurrentDictionary<ServerIdentifier, int>();
MatchIndex = new ConcurrentDictionary<ServerIdentifier, int>();
_hartbeat.Leader(SendHartbeat);
_replyDispose = reply.Subscribe(EntryReplyMessageRecived);
_clientReplyDispose = client.Subscribe(ClientMessageRecived);
}
