protected AppendEntryBaseTest() { // Arrange var mocker = new AutoMocker(); ServerIdentifier = new ServerIdentifier(); mocker.Use(ServerIdentifier); mocker.Setup<ISubject<AppendEntryMessage>>(p => p.Subscribe(It.IsAny<IObserver<AppendEntryMessage>>())) .Callback<IObserver<AppendEntryMessage>>((o) => { AppendEntryCallback = o; }); AppendEntryCallback = mocker.Get<ISubject<AppendEntryMessage>>(); AppendEntryResult = new Subject<AppendEntryResultMessage>(); Election = new Election(); LogReplication = new LogReplication(); AppendEntry = new Rafting.AppendEntry(AppendEntryResult, mocker.Get<ISubject<AppendEntryMessage>>(), mocker.Get<IHartbeatTimer>(), LogReplication, Election, mocker.Get<ILoggerFactory>(), new RaftOptions(), mocker.Get<ServerIdentifier>(), null); }
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 KvPropertyService( IRepository <KvProperty> kvPropertyRepository, IKvPropertyValidator kvPropertyValidator, ILogReplication logReplication, IConsensusContext consensusContext) { _kvPropertyRepository = kvPropertyRepository; _kvPropertyValidator = kvPropertyValidator; _logReplication = logReplication; _consensusContext = consensusContext; }
public ServicesService( IRepository <Service> serviceRepository, IServiceValidator serviceValidator, IMemoryCache memoryCache, IServiceHealthWorker serviceHealthWorker, ILogReplication logReplication, IConsensusContext consensusContext) { _serviceRepository = serviceRepository; _serviceValidator = serviceValidator; _memoryCache = memoryCache; _serviceHealthWorker = serviceHealthWorker; _logReplication = logReplication; _consensusContext = consensusContext; }
public VoteReceived(IObserver<RequestVoteResultMessage> voteReply, ServerIdentifier serverIdentifier, IObservable<RequestVoteMessage> requestVote, Election election, ILoggerFactory loggerFactory, Nodes nodes, RaftOptions options, ILogReplication logReplication) { _voteReply = voteReply; _election = election; _nodes = nodes; _options = options; _logReplication = logReplication; _serverIdentifier = serverIdentifier; _voteReceivedDisposable = requestVote.Subscribe(VoteRequestReceived); _logger = loggerFactory.CreateLogger(nameof(VoteReceived) + " " + serverIdentifier); }
public AppendEntry(IObserver<AppendEntryResultMessage> entryReply, IObservable<AppendEntryMessage> receivedAppendEntryMessage, IHartbeatTimer hartbeat, ILogReplication logReplication, Election election, ILoggerFactory loggerFactory, RaftOptions options, ServerIdentifier serverIdentifier, IEnumerable<IRaftService> services) { _entryReply = entryReply; _hartbeat = hartbeat; _receivedDisposable = receivedAppendEntryMessage.Subscribe(RaciveHartbeat); _logReplication = logReplication; _election = election; _options = options; _serverIdentifier = serverIdentifier; _services = services; _logger = loggerFactory.CreateLogger(nameof(AppendEntry) + " " + serverIdentifier); }
public ServiceHealthWorker( IRepository <Service> serviceRepository, IRepository <ServiceHealth> serviceHealthRepository, ILogger <ServiceHealthWorker> logger, IMemoryCache memoryCache, IApplicationLifetime applicationLifetime, HttpClient httpClient, ILogReplication logReplication) { _serviceRepository = serviceRepository; _serviceHealthRepository = serviceHealthRepository; _logger = logger; _memoryCache = memoryCache; _applicationLifetime = applicationLifetime; _httpClient = httpClient; _logReplication = logReplication; _applicationLifetime.ApplicationStopping.Register(DisposeResources); _tokenSources = new ConcurrentDictionary <string, CancellationTokenSource>(); }
public Node(IVoteReceived voteReceived, IAppendEntry appendEntry, IHartbeatTimer hartbeat, ILoggerFactory loggerFactory, IObservableProvider observableProvider, ILogReplication logReplication, ServerIdentifier serverIdentifier) { _logReplication = logReplication; _serverIdentifier = serverIdentifier; _hartbeatTimer = hartbeat; _stateMachine = new Machine<ServerStateType, ServerStateType>(ServerStateType.Candidate, loggerFactory, observableProvider); _stateMachine.On(ServerStateType.Follower) .OnEntry(() => { hartbeat.Subscribe(_stateMachine); }) .OnEntrySubscribe<Follower>() .Permit(ServerStateType.Candidate, ServerStateType.Candidate); _stateMachine.On(ServerStateType.Candidate) .OnEntrySubscribe<Candidate>() .OnEntry(hartbeat.Reset) .Permit(ServerStateType.Follower, ServerStateType.Follower) .Permit(ServerStateType.Leader, ServerStateType.Leader) .Permit(ServerStateType.Candidate, ServerStateType.Candidate); _stateMachine.On(ServerStateType.Leader) .OnEntrySubscribe<Leader>() .Permit(ServerStateType.Follower, ServerStateType.Follower); _voteReceivedeDispose = voteReceived.Subscribe(_stateMachine); _appendEntryDispose = appendEntry.Subscribe(_stateMachine); _stateMachine.OnNext(ServerStateType.Follower); }
public LeaderBaseTests() { var mocker = new AutoMocker(); ServerIdentifier = new ServerIdentifier(); mocker.Use(ServerIdentifier); Election = new Election(); AppendEntryResult = new Subject<AppendEntryResultMessage>(); AppendEntry = new Subject<AppendEntryMessage>(); LogReplication = new LogReplication(); Nodes = new Nodes(); Leader = new Rafting.States.Leader( Election, mocker.Get<IHartbeatTimer>(), AppendEntryResult, AppendEntry, mocker.Get<IObserver<ClientResultMessage>>(), mocker.Get<IObservable<ClientMessage>>(), LogReplication, Nodes, mocker.Get<ILoggerFactory>(), new RaftOptions(), mocker.Get<ServerIdentifier>()); }
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); }