@Override public Collection<MemberId> members() { return Futures.get(election.getTerm()) .candidates() .stream() .map(GroupMember::memberId) .collect(Collectors.toList()); }
PrimaryTerm term() { return new PrimaryTerm(term, primary(), candidates()); }
@Override public CompletableFuture<Void> consume(long index, Consumer<LogRecord> consumer) { return term().thenCompose(term -> { protocol.registerRecordsConsumer(subject, this::handleRecords, threadContext); this.consumer = consumer; this.index = index - 1; return register(term.primary().memberId()); }); } }
&& Objects.equals(currentTerm.primary(), primary) && Objects.equals(currentTerm.candidates(), candidates) ? currentTerm() : incrementTerm(); PrimaryTerm newTerm = new PrimaryTerm(term, primary, candidates); if (!Objects.equals(currentTerm, newTerm)) { this.currentTerm = newTerm;
@Override public MemberId primary() { return Futures.get(election.getTerm()) .primary() .memberId(); }
@Override public long term() { return Futures.get(election.getTerm()).term(); }
@Override public CompletableFuture<byte[]> execute(PrimitiveOperation operation) { ComposableFuture<byte[]> future = new ComposableFuture<>(); threadContext.execute(() -> { if (term.primary() == null) { primaryElection.getTerm().whenCompleteAsync((term, error) -> { if (error == null) { if (term.term() <= this.term.term() || term.primary() == null) { future.completeExceptionally(new PrimitiveException.Unavailable()); } else { this.term = term; execute(operation, 1, future); } } else { future.completeExceptionally(new PrimitiveException.Unavailable()); } }, threadContext); } else { execute(operation, 1, future); } }); return future; }
@Override public MemberId primary() { return Futures.get(election.getTerm()) .primary() .memberId(); }
@Override public Collection<MemberId> backups() { return Futures.get(election.getTerm()) .candidates() .stream() .map(GroupMember::memberId) .collect(Collectors.toList()); }
@Override public long term() { return Futures.get(election.getTerm()).term(); }
log.trace("Sending {} to {}", request, term.primary()); PrimaryTerm term = this.term; if (term.primary() != null) { protocol.execute(term.primary().memberId(), request).whenCompleteAsync((response, error) -> { if (error == null) { log.trace("Received {}", response); if (response.status() == Status.OK) { future.complete(response.result()); } else if (this.term.term() > term.term()) { execute(operation).whenComplete(future); } else { primaryElection.getTerm().whenComplete((newTerm, termError) -> { if (termError == null) { if (newTerm.term() > term.term() && newTerm.primary() != null) { execute(operation).whenComplete(future); } else { } else if (this.term.term() > term.term()) { execute(operation).whenComplete(future); } else {
@Override public CompletableFuture<Long> append(byte[] value) { CompletableFuture<Long> future = new CompletableFuture<>(); term().thenCompose(term -> protocol.append(term.primary().memberId(), AppendRequest.request(value))) .whenCompleteAsync((response, error) -> { if (error == null) { if (response.status() == LogResponse.Status.OK) { future.complete(response.index()); } else { future.completeExceptionally(new PrimitiveException.Unavailable()); } } else { future.completeExceptionally(error); } }, threadContext); return future; } }
@Override public Collection<MemberId> backups() { return Futures.get(election.getTerm()) .candidates() .stream() .map(GroupMember::memberId) .collect(Collectors.toList()); }
private void updateTerm(long term) { if (term > currentTerm.term()) { recomputeTerm(groupMembershipService.getMembership(partitionId.group())); } }