You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ratis.apache.org by ta...@apache.org on 2024/11/01 08:58:03 UTC
(ratis) branch release-3.1.2_review created (now 2981c6b15)
This is an automated email from the ASF dual-hosted git repository.
tanxinyu pushed a change to branch release-3.1.2_review
in repository https://gitbox.apache.org/repos/asf/ratis.git
at 2981c6b15 RATIS-2178. Add a log message whenever deleting a RaftLog segment. (#1170)
This branch includes the following new commits:
new fbb9b5a66 RATIS-2172. RaftServer may lose FollowerState (#1166)
new 7f10888a4 RATIS-2174. Move future.join outside the lock (#1168)
new 263ea69b2 RATIS-2179. Fix NPE in RaftServerImpl.getLogInfo. (#1171)
new 2981c6b15 RATIS-2178. Add a log message whenever deleting a RaftLog segment. (#1170)
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(ratis) 03/04: RATIS-2179. Fix NPE in RaftServerImpl.getLogInfo. (#1171)
Posted by ta...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
tanxinyu pushed a commit to branch release-3.1.2_review
in repository https://gitbox.apache.org/repos/asf/ratis.git
commit 263ea69b2ff295355dc7f2074bf7cf69a820e8b2
Author: Nicholas Jiang <pr...@163.com>
AuthorDate: Fri Oct 25 15:31:27 2024 +0800
RATIS-2179. Fix NPE in RaftServerImpl.getLogInfo. (#1171)
---
.../org/apache/ratis/server/impl/RaftServerImpl.java | 17 +++++++++++++----
1 file changed, 13 insertions(+), 4 deletions(-)
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java b/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
index ba7d8668c..3ffcee079 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
@@ -664,10 +664,19 @@ class RaftServerImpl implements RaftServer.Division,
LogInfoProto getLogInfo(){
final RaftLog log = getRaftLog();
- LogInfoProto.Builder logInfoBuilder = LogInfoProto.newBuilder()
- .setApplied(getStateMachine().getLastAppliedTermIndex().toProto())
- .setCommitted(log.getTermIndex(log.getLastCommittedIndex()).toProto())
- .setLastEntry(log.getLastEntryTermIndex().toProto());
+ LogInfoProto.Builder logInfoBuilder = LogInfoProto.newBuilder();
+ final TermIndex applied = getStateMachine().getLastAppliedTermIndex();
+ if (applied != null) {
+ logInfoBuilder.setApplied(applied.toProto());
+ }
+ final TermIndex committed = log.getTermIndex(log.getLastCommittedIndex());
+ if (committed != null) {
+ logInfoBuilder.setCommitted(committed.toProto());
+ }
+ final TermIndex entry = log.getLastEntryTermIndex();
+ if (entry != null) {
+ logInfoBuilder.setLastEntry(entry.toProto());
+ }
final SnapshotInfo snapshot = getStateMachine().getLatestSnapshot();
if (snapshot != null) {
logInfoBuilder.setLastSnapshot(snapshot.getTermIndex().toProto());
(ratis) 02/04: RATIS-2174. Move future.join outside the lock (#1168)
Posted by ta...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
tanxinyu pushed a commit to branch release-3.1.2_review
in repository https://gitbox.apache.org/repos/asf/ratis.git
commit 7f10888a4150fac9426f3862c2b25e6301039465
Author: 133tosakarin <97...@users.noreply.github.com>
AuthorDate: Tue Oct 22 02:26:53 2024 +0800
RATIS-2174. Move future.join outside the lock (#1168)
---
.../apache/ratis/server/impl/LeaderElection.java | 1 -
.../apache/ratis/server/impl/LeaderStateImpl.java | 2 +-
.../apache/ratis/server/impl/RaftServerImpl.java | 34 +++++++++---------
.../server/impl/SnapshotInstallationHandler.java | 41 +++++++++++++---------
4 files changed, 44 insertions(+), 34 deletions(-)
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderElection.java b/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderElection.java
index 4badd09cd..39b401dda 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderElection.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderElection.java
@@ -227,7 +227,6 @@ class LeaderElection implements Runnable {
CompletableFuture<Void> shutdown() {
lifeCycle.checkStateAndClose();
- stopped.complete(null);
return stopped;
}
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderStateImpl.java b/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderStateImpl.java
index 3d8bc2219..0dfbf263d 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderStateImpl.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderStateImpl.java
@@ -705,7 +705,7 @@ class LeaderStateImpl implements LeaderState {
private void stepDown(long term, StepDownReason reason) {
try {
lease.getAndSetEnabled(false);
- server.changeToFollowerAndPersistMetadata(term, false, reason);
+ server.changeToFollowerAndPersistMetadata(term, false, reason).join();
pendingStepDown.complete(server::newSuccessReply);
} catch(IOException e) {
final String s = this + ": Failed to persist metadata for term " + term;
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java b/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
index 1ac62fd98..ba7d8668c 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
@@ -132,7 +132,6 @@ import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
@@ -570,14 +569,8 @@ class RaftServerImpl implements RaftServer.Division,
* @param force Force to start a new {@link FollowerState} even if this server is already a follower.
* @return if the term/votedFor should be updated to the new term
*/
- private boolean changeToFollower(long newTerm, boolean force, boolean allowListener, Object reason) {
- final AtomicReference<Boolean> metadataUpdated = new AtomicReference<>();
- changeToFollowerAsync(newTerm, force, allowListener, reason, metadataUpdated).join();
- return metadataUpdated.get();
- }
-
- private synchronized CompletableFuture<Void> changeToFollowerAsync(
- long newTerm, boolean force, boolean allowListener, Object reason, AtomicReference<Boolean> metadataUpdated) {
+ private synchronized CompletableFuture<Void> changeToFollower(
+ long newTerm, boolean force, boolean allowListener, Object reason, AtomicBoolean metadataUpdated) {
final RaftPeerRole old = role.getCurrentRole();
if (old == RaftPeerRole.LISTENER && !allowListener) {
throw new IllegalStateException("Unexpected role " + old);
@@ -612,13 +605,16 @@ class RaftServerImpl implements RaftServer.Division,
return future;
}
- synchronized void changeToFollowerAndPersistMetadata(
+ synchronized CompletableFuture<Void> changeToFollowerAndPersistMetadata(
long newTerm,
boolean allowListener,
Object reason) throws IOException {
- if (changeToFollower(newTerm, false, allowListener, reason)) {
+ final AtomicBoolean metadataUpdated = new AtomicBoolean();
+ final CompletableFuture<Void> future = changeToFollower(newTerm, false, allowListener, reason, metadataUpdated);
+ if (metadataUpdated.get()) {
state.persistMetadata();
}
+ return future;
}
synchronized void changeToLeader() {
@@ -1406,6 +1402,7 @@ class RaftServerImpl implements RaftServer.Division,
boolean shouldShutdown = false;
final RequestVoteReplyProto reply;
+ CompletableFuture<Void> future = null;
synchronized (this) {
// Check life cycle state again to avoid the PAUSING/PAUSED state.
assertLifeCycleState(LifeCycle.States.RUNNING);
@@ -1415,12 +1412,12 @@ class RaftServerImpl implements RaftServer.Division,
final boolean voteGranted = context.decideVote(candidate, candidateLastEntry);
if (candidate != null && phase == Phase.ELECTION) {
// change server state in the ELECTION phase
- final boolean termUpdated =
- changeToFollower(candidateTerm, true, false, "candidate:" + candidateId);
+ final AtomicBoolean termUpdated = new AtomicBoolean();
+ future = changeToFollower(candidateTerm, true, false, "candidate:" + candidateId, termUpdated);
if (voteGranted) {
state.grantVote(candidate.getId());
}
- if (termUpdated || voteGranted) {
+ if (termUpdated.get() || voteGranted) {
state.persistMetadata(); // sync metafile
}
}
@@ -1436,6 +1433,9 @@ class RaftServerImpl implements RaftServer.Division,
getMemberId(), phase, toRequestVoteReplyString(reply), state);
}
}
+ if (future != null) {
+ future.join();
+ }
return reply;
}
@@ -1533,6 +1533,7 @@ class RaftServerImpl implements RaftServer.Division,
final long followerCommit = state.getLog().getLastCommittedIndex();
final Optional<FollowerState> followerState;
final Timekeeper.Context timer = raftServerMetrics.getFollowerAppendEntryTimer(isHeartbeat).time();
+ final CompletableFuture<Void> future;
synchronized (this) {
// Check life cycle state again to avoid the PAUSING/PAUSED state.
assertLifeCycleState(LifeCycle.States.STARTING_OR_RUNNING);
@@ -1544,7 +1545,7 @@ class RaftServerImpl implements RaftServer.Division,
AppendResult.NOT_LEADER, callId, RaftLog.INVALID_LOG_INDEX, isHeartbeat));
}
try {
- changeToFollowerAndPersistMetadata(leaderTerm, true, "appendEntries");
+ future = changeToFollowerAndPersistMetadata(leaderTerm, true, "appendEntries");
} catch (IOException e) {
return JavaUtils.completeExceptionally(e);
}
@@ -1569,11 +1570,12 @@ class RaftServerImpl implements RaftServer.Division,
AppendResult.INCONSISTENCY, callId, RaftLog.INVALID_LOG_INDEX, isHeartbeat);
LOG.info("{}: appendEntries* reply {}", getMemberId(), toAppendEntriesReplyString(reply));
followerState.ifPresent(fs -> fs.updateLastRpcTime(FollowerState.UpdateType.APPEND_COMPLETE));
- return CompletableFuture.completedFuture(reply);
+ return future.thenApply(dummy -> reply);
}
state.updateConfiguration(entries);
}
+ future.join();
final List<CompletableFuture<Long>> futures = entries.isEmpty() ? Collections.emptyList()
: state.getLog().append(entries);
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/impl/SnapshotInstallationHandler.java b/ratis-server/src/main/java/org/apache/ratis/server/impl/SnapshotInstallationHandler.java
index 537b384c6..8de9a3756 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/impl/SnapshotInstallationHandler.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/impl/SnapshotInstallationHandler.java
@@ -46,6 +46,7 @@ import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
@@ -122,12 +123,12 @@ class SnapshotInstallationHandler {
if (installSnapshotEnabled) {
// Leader has sent InstallSnapshot request with SnapshotInfo. Install the snapshot.
if (request.hasSnapshotChunk()) {
- reply = checkAndInstallSnapshot(request, leaderId);
+ reply = checkAndInstallSnapshot(request, leaderId).join();
}
} else {
// Leader has only sent a notification to install snapshot. Inform State Machine to install snapshot.
if (request.hasNotification()) {
- reply = notifyStateMachineToInstallSnapshot(request, leaderId);
+ reply = notifyStateMachineToInstallSnapshot(request, leaderId).join();
}
}
@@ -156,21 +157,22 @@ class SnapshotInstallationHandler {
return failedReply;
}
- private InstallSnapshotReplyProto checkAndInstallSnapshot(InstallSnapshotRequestProto request,
+ private CompletableFuture<InstallSnapshotReplyProto> checkAndInstallSnapshot(InstallSnapshotRequestProto request,
RaftPeerId leaderId) throws IOException {
final long currentTerm;
final long leaderTerm = request.getLeaderTerm();
final InstallSnapshotRequestProto.SnapshotChunkProto snapshotChunkRequest = request.getSnapshotChunk();
final TermIndex lastIncluded = TermIndex.valueOf(snapshotChunkRequest.getTermIndex());
final long lastIncludedIndex = lastIncluded.getIndex();
+ final CompletableFuture<Void> future;
synchronized (server) {
final boolean recognized = state.recognizeLeader(RaftServerProtocol.Op.INSTALL_SNAPSHOT, leaderId, leaderTerm);
currentTerm = state.getCurrentTerm();
if (!recognized) {
- return toInstallSnapshotReplyProto(leaderId, getMemberId(),
- currentTerm, snapshotChunkRequest.getRequestIndex(), InstallSnapshotResult.NOT_LEADER);
+ return CompletableFuture.completedFuture(toInstallSnapshotReplyProto(leaderId, getMemberId(),
+ currentTerm, snapshotChunkRequest.getRequestIndex(), InstallSnapshotResult.NOT_LEADER));
}
- server.changeToFollowerAndPersistMetadata(leaderTerm, true, "installSnapshot");
+ future = server.changeToFollowerAndPersistMetadata(leaderTerm, true, "installSnapshot");
state.setLeader(leaderId, "installSnapshot");
server.updateLastRpcTime(FollowerState.UpdateType.INSTALL_SNAPSHOT_START);
@@ -186,8 +188,9 @@ class SnapshotInstallationHandler {
// have a lot of requests
if (state.getLog().getLastCommittedIndex() >= lastIncludedIndex) {
nextChunkIndex.set(snapshotChunkRequest.getRequestIndex() + 1);
- return toInstallSnapshotReplyProto(leaderId, getMemberId(),
+ final InstallSnapshotReplyProto reply = toInstallSnapshotReplyProto(leaderId, getMemberId(),
currentTerm, snapshotChunkRequest.getRequestIndex(), InstallSnapshotResult.ALREADY_INSTALLED);
+ return future.thenApply(dummy -> reply);
}
//TODO: We should only update State with installed snapshot once the request is done.
@@ -210,25 +213,27 @@ class SnapshotInstallationHandler {
if (snapshotChunkRequest.getDone()) {
LOG.info("{}: successfully install the entire snapshot-{}", getMemberId(), lastIncludedIndex);
}
- return toInstallSnapshotReplyProto(leaderId, getMemberId(),
+ final InstallSnapshotReplyProto reply = toInstallSnapshotReplyProto(leaderId, getMemberId(),
currentTerm, snapshotChunkRequest.getRequestIndex(), InstallSnapshotResult.SUCCESS);
+ return future.thenApply(dummy -> reply);
}
- private InstallSnapshotReplyProto notifyStateMachineToInstallSnapshot(
+ private CompletableFuture<InstallSnapshotReplyProto> notifyStateMachineToInstallSnapshot(
InstallSnapshotRequestProto request, RaftPeerId leaderId) throws IOException {
final long currentTerm;
final long leaderTerm = request.getLeaderTerm();
final TermIndex firstAvailableLogTermIndex = TermIndex.valueOf(
request.getNotification().getFirstAvailableTermIndex());
final long firstAvailableLogIndex = firstAvailableLogTermIndex.getIndex();
+ final CompletableFuture<Void> future;
synchronized (server) {
final boolean recognized = state.recognizeLeader("notifyInstallSnapshot", leaderId, leaderTerm);
currentTerm = state.getCurrentTerm();
if (!recognized) {
- return toInstallSnapshotReplyProto(leaderId, getMemberId(),
- currentTerm, InstallSnapshotResult.NOT_LEADER);
+ return CompletableFuture.completedFuture(toInstallSnapshotReplyProto(leaderId, getMemberId(),
+ currentTerm, InstallSnapshotResult.NOT_LEADER));
}
- server.changeToFollowerAndPersistMetadata(leaderTerm, true, "installSnapshot");
+ future = server.changeToFollowerAndPersistMetadata(leaderTerm, true, "installSnapshot");
state.setLeader(leaderId, "installSnapshot");
server.updateLastRpcTime(FollowerState.UpdateType.INSTALL_SNAPSHOT_NOTIFICATION);
@@ -245,8 +250,9 @@ class SnapshotInstallationHandler {
inProgressInstallSnapshotIndex.compareAndSet(firstAvailableLogIndex, INVALID_LOG_INDEX);
LOG.info("{}: InstallSnapshot notification result: {}, current snapshot index: {}", getMemberId(),
InstallSnapshotResult.ALREADY_INSTALLED, snapshotIndex);
- return toInstallSnapshotReplyProto(leaderId, getMemberId(), currentTerm,
+ final InstallSnapshotReplyProto reply = toInstallSnapshotReplyProto(leaderId, getMemberId(), currentTerm,
InstallSnapshotResult.ALREADY_INSTALLED, snapshotIndex);
+ return future.thenApply(dummy -> reply);
}
final RaftPeerProto leaderProto;
@@ -323,8 +329,9 @@ class SnapshotInstallationHandler {
inProgressInstallSnapshotIndex.set(INVALID_LOG_INDEX);
server.getStateMachine().event().notifySnapshotInstalled(
InstallSnapshotResult.SNAPSHOT_UNAVAILABLE, INVALID_LOG_INDEX, server.getPeer());
- return toInstallSnapshotReplyProto(leaderId, getMemberId(),
+ final InstallSnapshotReplyProto reply = toInstallSnapshotReplyProto(leaderId, getMemberId(),
currentTerm, InstallSnapshotResult.SNAPSHOT_UNAVAILABLE);
+ return future.thenApply(dummy -> reply);
}
// If a snapshot has been installed, return SNAPSHOT_INSTALLED with the installed snapshot index and reset
@@ -341,8 +348,9 @@ class SnapshotInstallationHandler {
server.getStateMachine().event().notifySnapshotInstalled(
InstallSnapshotResult.SNAPSHOT_INSTALLED, latestInstalledIndex, server.getPeer());
installedIndex.set(latestInstalledIndex);
- return toInstallSnapshotReplyProto(leaderId, getMemberId(),
+ final InstallSnapshotReplyProto reply = toInstallSnapshotReplyProto(leaderId, getMemberId(),
currentTerm, InstallSnapshotResult.SNAPSHOT_INSTALLED, latestInstalledSnapshotTermIndex.getIndex());
+ return future.thenApply(dummy -> reply);
}
// Otherwise, Snapshot installation is in progress.
@@ -350,8 +358,9 @@ class SnapshotInstallationHandler {
LOG.debug("{}: InstallSnapshot notification result: {}", getMemberId(),
InstallSnapshotResult.IN_PROGRESS);
}
- return toInstallSnapshotReplyProto(leaderId, getMemberId(),
+ final InstallSnapshotReplyProto reply = toInstallSnapshotReplyProto(leaderId, getMemberId(),
currentTerm, InstallSnapshotResult.IN_PROGRESS);
+ return future.thenApply(dummy -> reply);
}
}
(ratis) 01/04: RATIS-2172. RaftServer may lose FollowerState (#1166)
Posted by ta...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
tanxinyu pushed a commit to branch release-3.1.2_review
in repository https://gitbox.apache.org/repos/asf/ratis.git
commit fbb9b5a663cc5e7a2ae2c8fab04d507f77189df7
Author: 133tosakarin <97...@users.noreply.github.com>
AuthorDate: Sat Oct 12 05:55:35 2024 +0800
RATIS-2172. RaftServer may lose FollowerState (#1166)
---
.../apache/ratis/util/CodeInjectionForTesting.java | 5 ++
.../apache/ratis/server/impl/FollowerState.java | 13 ++--
.../apache/ratis/server/impl/LeaderElection.java | 4 --
.../apache/ratis/server/impl/RaftServerImpl.java | 6 +-
.../ratis/server/impl/LeaderElectionTests.java | 77 ++++++++++++++++++++++
5 files changed, 96 insertions(+), 9 deletions(-)
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/CodeInjectionForTesting.java b/ratis-common/src/main/java/org/apache/ratis/util/CodeInjectionForTesting.java
index a7d36ac0e..112f6bd25 100644
--- a/ratis-common/src/main/java/org/apache/ratis/util/CodeInjectionForTesting.java
+++ b/ratis-common/src/main/java/org/apache/ratis/util/CodeInjectionForTesting.java
@@ -68,4 +68,9 @@ public final class CodeInjectionForTesting {
}
return code.execute(localId, remoteId, args);
}
+
+ /** Remove an injection point. */
+ public static void remove(String injectionPoint) {
+ INJECTION_POINTS.remove(injectionPoint);
+ }
}
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/impl/FollowerState.java b/ratis-server/src/main/java/org/apache/ratis/server/impl/FollowerState.java
index fa61e9088..1be160f18 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/impl/FollowerState.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/impl/FollowerState.java
@@ -133,6 +133,14 @@ class FollowerState extends Daemon {
}
}
+ private boolean roleChangeChecking(TimeDuration electionTimeout) {
+ return outstandingOp.get() == 0
+ && isRunning && server.getInfo().isFollower()
+ && lastRpcTime.elapsedTime().compareTo(electionTimeout) >= 0
+ && !lostMajorityHeartbeatsRecently()
+ && server.isRunning();
+ }
+
private void runImpl() {
final TimeDuration sleepDeviationThreshold = server.getSleepDeviationThreshold();
while (shouldRun()) {
@@ -149,10 +157,7 @@ class FollowerState extends Daemon {
break;
}
synchronized (server) {
- if (outstandingOp.get() == 0
- && isRunning && server.getInfo().isFollower()
- && lastRpcTime.elapsedTime().compareTo(electionTimeout) >= 0
- && !lostMajorityHeartbeatsRecently()) {
+ if (roleChangeChecking(electionTimeout)) {
LOG.info("{}: change to CANDIDATE, lastRpcElapsedTime:{}, electionTimeout:{}",
this, lastRpcTime.elapsedTime(), electionTimeout);
server.getLeaderElectionMetrics().onLeaderElectionTimeout(); // Update timeout metric counters.
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderElection.java b/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderElection.java
index a5bfba7be..4badd09cd 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderElection.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/impl/LeaderElection.java
@@ -253,10 +253,6 @@ class LeaderElection implements Runnable {
}
try (AutoCloseable ignored = Timekeeper.start(server.getLeaderElectionMetrics().getLeaderElectionTimer())) {
- if (!server.isRunning()) {
- LOG.info("{}: skip since the server is not running", this);
- return;
- }
for (int round = 0; shouldRun(); round++) {
if (skipPreVote || askForVotes(Phase.PRE_VOTE, round)) {
if (askForVotes(Phase.ELECTION, round)) {
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java b/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
index ae158ad75..1ac62fd98 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/impl/RaftServerImpl.java
@@ -160,6 +160,7 @@ class RaftServerImpl implements RaftServer.Division,
static final String APPEND_TRANSACTION = CLASS_NAME + ".appendTransaction";
static final String LOG_SYNC = APPEND_ENTRIES + ".logComplete";
static final String START_LEADER_ELECTION = CLASS_NAME + ".startLeaderElection";
+ static final String START_COMPLETE = CLASS_NAME + ".startComplete";
class Info implements DivisionInfo {
@Override
@@ -400,7 +401,10 @@ class RaftServerImpl implements RaftServer.Division,
jmxAdapter.registerMBean();
state.start();
- startComplete.compareAndSet(false, true);
+ CodeInjectionForTesting.execute(START_COMPLETE, getId(), null, role);
+ if (startComplete.compareAndSet(false, true)) {
+ LOG.info("{}: Successfully started.", getMemberId());
+ }
return true;
}
diff --git a/ratis-server/src/test/java/org/apache/ratis/server/impl/LeaderElectionTests.java b/ratis-server/src/test/java/org/apache/ratis/server/impl/LeaderElectionTests.java
index b29b537ab..b175ffe29 100644
--- a/ratis-server/src/test/java/org/apache/ratis/server/impl/LeaderElectionTests.java
+++ b/ratis-server/src/test/java/org/apache/ratis/server/impl/LeaderElectionTests.java
@@ -29,6 +29,7 @@ import org.apache.ratis.protocol.RaftGroupId;
import org.apache.ratis.protocol.RaftGroupMemberId;
import org.apache.ratis.protocol.RaftPeer;
import org.apache.ratis.protocol.RaftPeerId;
+import org.apache.ratis.protocol.SetConfigurationRequest;
import org.apache.ratis.protocol.exceptions.LeaderSteppingDownException;
import org.apache.ratis.protocol.exceptions.TransferLeadershipException;
import org.apache.ratis.server.DivisionInfo;
@@ -44,6 +45,8 @@ import org.apache.ratis.util.Slf4jUtils;
import org.apache.ratis.util.TimeDuration;
import org.apache.ratis.util.Timestamp;
import org.apache.ratis.util.function.CheckedBiConsumer;
+import org.apache.ratis.util.CodeInjectionForTesting;
+import org.junit.Assert;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
@@ -97,6 +100,80 @@ public abstract class LeaderElectionTests<CLUSTER extends MiniRaftCluster>
cluster.shutdown();
}
+ static class SleepCode implements CodeInjectionForTesting.Code {
+ private final long sleepMs;
+
+ SleepCode(long sleepMs) {
+ this.sleepMs = sleepMs;
+ }
+
+ @Override
+ public boolean execute(Object localId, Object remoteId, Object... args) {
+ try {
+ LOG.info("{}: Simulate RaftServer startup blocking", localId);
+ Thread.sleep(sleepMs);
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ return true;
+ }
+ }
+
+ @Test
+ public void testWaitServerReady() throws Exception {
+ final int sleepMs = 1000 + ThreadLocalRandom.current().nextInt(1000);
+ LOG.info("Running testWaitServerReady, sleep = {}ms", sleepMs);
+ CodeInjectionForTesting.put(RaftServerImpl.START_COMPLETE, new SleepCode(sleepMs));
+ final MiniRaftCluster cluster = newCluster(1);
+ final Timestamp startTime = Timestamp.currentTime();
+ cluster.start();
+ LOG.info("Cluster started at {}ms", startTime.elapsedTimeMs());
+ final RaftGroupId groupId = cluster.getGroupId();
+ final RaftServerImpl server = (RaftServerImpl) cluster.getServers().iterator().next().getDivision(groupId);
+ final boolean isRunning = server.isRunning();
+ LOG.info("{} isRunning at {}ms? {}", server.getId(), startTime.elapsedTimeMs(), isRunning);
+
+ // Leader will be elected if the server is ready
+ Assertions.assertNotNull(waitForLeader(cluster), "No leader is elected.");
+ final long elapsedMs = startTime.elapsedTimeMs();
+ // allow a small difference to tolerate system timer inaccuracy
+ Assertions.assertTrue(elapsedMs > sleepMs - 10, () -> "elapseMs = " + elapsedMs + " but sleepMs = " + sleepMs);
+ cluster.shutdown();
+ CodeInjectionForTesting.remove(RaftServerImpl.START_COMPLETE);
+ }
+
+ @Test
+ public void testAddServerForWaitReady() throws IOException, InterruptedException {
+ LOG.info("Running testAddServerForWaitReady");
+ // normal startup cluster with 3 server
+ final MiniRaftCluster cluster = newCluster(3);
+ cluster.start();
+ RaftTestUtil.waitForLeader(cluster);
+ try (RaftClient client = cluster.createClient()) {
+ for (int i = 0; i < 10; ++i) {
+ RaftClientReply reply = client.io().send(new RaftTestUtil.SimpleMessage("message_" + i));
+ Assertions.assertTrue(reply.isSuccess());
+ }
+ // add 3 new servers and wait longer time
+ CodeInjectionForTesting.put(RaftServerImpl.START_COMPLETE, new SleepCode(2000));
+ MiniRaftCluster.PeerChanges peerChanges = cluster.addNewPeers(2, true, false);
+ LOG.info("add new 3 servers");
+ LOG.info(cluster.printServers());
+ RaftClientReply reply = client.admin().setConfiguration(SetConfigurationRequest.Arguments.newBuilder()
+ .setServersInNewConf(peerChanges.newPeers)
+ .setMode(SetConfigurationRequest.Mode.ADD).build());
+ Assert.assertTrue(reply.isSuccess());
+ for (RaftServer server : cluster.getServers()) {
+ RaftServerProxy proxy = (RaftServerProxy) server;
+ proxy.getImpls().forEach(s -> {
+ Assertions.assertTrue(s.isRunning());
+ });
+ }
+ }
+ cluster.shutdown();;
+ CodeInjectionForTesting.remove(RaftServerImpl.START_COMPLETE);
+ }
+
@Test
public void testChangeLeader() throws Exception {
SegmentedRaftLogTestUtils.setRaftLogWorkerLogLevel(Level.TRACE);
(ratis) 04/04: RATIS-2178. Add a log message whenever deleting a RaftLog segment. (#1170)
Posted by ta...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
tanxinyu pushed a commit to branch release-3.1.2_review
in repository https://gitbox.apache.org/repos/asf/ratis.git
commit 2981c6b158458a90ebad066415e43d07769afe7e
Author: Tsz-Wo Nicholas Sze <sz...@apache.org>
AuthorDate: Sun Oct 27 20:56:18 2024 -0700
RATIS-2178. Add a log message whenever deleting a RaftLog segment. (#1170)
---
.../main/java/org/apache/ratis/util/FileUtils.java | 6 ++-
.../ratis/server/raftlog/segmented/LogSegment.java | 7 +--
.../raftlog/segmented/LogSegmentStartEnd.java | 39 ++++++++++-----
.../server/raftlog/segmented/SegmentedRaftLog.java | 3 +-
.../raftlog/segmented/SegmentedRaftLogCache.java | 25 ++++++----
.../segmented/SegmentedRaftLogInputStream.java | 57 ++++++----------------
.../raftlog/segmented/SegmentedRaftLogWorker.java | 23 +++++----
.../segmented/SegmentedRaftLogTestUtils.java | 14 ++++--
.../apache/ratis/server/ServerRestartTests.java | 14 ++----
.../server/raftlog/segmented/TestLogSegment.java | 12 +++--
.../raftlog/segmented/TestRaftLogReadWrite.java | 12 +++--
11 files changed, 108 insertions(+), 104 deletions(-)
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/FileUtils.java b/ratis-common/src/main/java/org/apache/ratis/util/FileUtils.java
index d5141e917..63bf3a4e5 100644
--- a/ratis-common/src/main/java/org/apache/ratis/util/FileUtils.java
+++ b/ratis-common/src/main/java/org/apache/ratis/util/FileUtils.java
@@ -201,8 +201,10 @@ public interface FileUtils {
}
/** The same as passing f.toPath() to {@link #delete(Path)}. */
- static void deleteFile(File f) throws IOException {
- delete(f.toPath());
+ static Path deleteFile(File f) throws IOException {
+ final Path path = f.toPath();
+ delete(path);
+ return path;
}
/**
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/LogSegment.java b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/LogSegment.java
index 89a6e2050..1b55b9727 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/LogSegment.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/LogSegment.java
@@ -37,6 +37,7 @@ import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
+import java.nio.file.Path;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
@@ -127,8 +128,7 @@ public final class LogSegment {
CorruptionPolicy corruptionPolicy, SegmentedRaftLogMetrics raftLogMetrics, Consumer<LogEntryProto> entryConsumer)
throws IOException {
int count = 0;
- try (SegmentedRaftLogInputStream in = new SegmentedRaftLogInputStream(
- file, startEnd.getStartIndex(), startEnd.getEndIndex(), startEnd.isOpen(), maxOpSize, raftLogMetrics)) {
+ try(SegmentedRaftLogInputStream in = new SegmentedRaftLogInputStream(file, startEnd, maxOpSize, raftLogMetrics)) {
for(LogEntryProto prev = null, next; (next = in.nextEntry()) != null; prev = next) {
if (prev != null) {
Preconditions.assertTrue(next.getIndex() == prev.getIndex() + 1,
@@ -181,7 +181,8 @@ public final class LogSegment {
if (entryCount == 0) {
// The segment does not have any entries, delete the file.
- FileUtils.deleteFile(file);
+ final Path deleted = FileUtils.deleteFile(file);
+ LOG.info("Deleted RaftLog segment since entry count is zero: startEnd={}, path={}", startEnd, deleted);
return null;
} else if (file.length() > segment.getTotalFileSize()) {
// The segment has extra padding, truncate it.
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/LogSegmentStartEnd.java b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/LogSegmentStartEnd.java
index 6fbaeab62..4f0734ca9 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/LogSegmentStartEnd.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/LogSegmentStartEnd.java
@@ -22,14 +22,12 @@ import org.apache.ratis.server.storage.RaftStorage;
import org.apache.ratis.util.Preconditions;
import java.io.File;
-import java.util.Comparator;
import java.util.Objects;
-import java.util.Optional;
import java.util.regex.Pattern;
/**
* The start index and an end index of a log segment.
- *
+ * <p>
* This is a value-based class.
*/
public final class LogSegmentStartEnd implements Comparable<LogSegmentStartEnd> {
@@ -76,21 +74,24 @@ public final class LogSegmentStartEnd implements Comparable<LogSegmentStartEnd>
private final Long endIndex;
private LogSegmentStartEnd(long startIndex, Long endIndex) {
- Preconditions.assertTrue(startIndex >= RaftLog.LEAST_VALID_LOG_INDEX);
- Preconditions.assertTrue(endIndex == null || endIndex >= startIndex);
this.startIndex = startIndex;
this.endIndex = endIndex;
+
+ Preconditions.assertTrue(startIndex >= RaftLog.LEAST_VALID_LOG_INDEX, this);
+ if (endIndex != null) {
+ Preconditions.assertTrue(endIndex >= startIndex, this);
+ }
}
- public long getStartIndex() {
+ long getStartIndex() {
return startIndex;
}
- public long getEndIndex() {
- return Optional.ofNullable(endIndex).orElse(RaftLog.INVALID_LOG_INDEX);
+ long getEndIndex() {
+ return Objects.requireNonNull(endIndex, "endIndex");
}
- public boolean isOpen() {
+ boolean isOpen() {
return endIndex == null;
}
@@ -108,9 +109,21 @@ public final class LogSegmentStartEnd implements Comparable<LogSegmentStartEnd>
@Override
public int compareTo(LogSegmentStartEnd that) {
- return Comparator.comparingLong(LogSegmentStartEnd::getStartIndex)
- .thenComparingLong(LogSegmentStartEnd::getEndIndex)
- .compare(this, that);
+ if (this == that) {
+ return 0;
+ }
+ // startIndex always non-null
+ final int diff = Long.compare(this.getStartIndex(), that.getStartIndex());
+ if (diff != 0) {
+ return diff;
+ }
+
+ // same startIndex, compare endIndex
+ if (this.isOpen()) {
+ return that.isOpen()? 0 : -1; //open first
+ } else {
+ return that.isOpen() ? 1 : Long.compare(this.endIndex, that.endIndex);
+ }
}
@Override
@@ -131,6 +144,6 @@ public final class LogSegmentStartEnd implements Comparable<LogSegmentStartEnd>
@Override
public String toString() {
- return startIndex + "-" + Optional.ofNullable(endIndex).map(Object::toString).orElse("");
+ return startIndex + "-" + (endIndex != null? endIndex : "");
}
}
\ No newline at end of file
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLog.java b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLog.java
index f49900f16..6dc3d7961 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLog.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLog.java
@@ -378,12 +378,13 @@ public final class SegmentedRaftLog extends RaftLogBase {
try (AutoCloseableLock writeLock = writeLock()) {
SegmentedRaftLogCache.TruncationSegments ts = cache.purge(index);
updateSnapshotIndexFromStateMachine();
- LOG.debug("purging segments:{}", ts);
if (ts != null) {
+ LOG.info("{}: {}", getName(), ts);
Task task = fileLogWorker.purge(ts);
return task.getFuture();
}
}
+ LOG.debug("{}: purge({}) found nothing to purge.", getName(), index);
return CompletableFuture.completedFuture(index);
}
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogCache.java b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogCache.java
index 58c70c4af..20b7a5c37 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogCache.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogCache.java
@@ -122,9 +122,14 @@ public class SegmentedRaftLogCache {
}
static class TruncationSegments {
+ private final String reason;
private final SegmentFileInfo toTruncate; // name of the file to be truncated
private final SegmentFileInfo[] toDelete; // names of the files to be deleted
+ String getReason() {
+ return reason;
+ }
+
public SegmentFileInfo getToTruncate() {
return toTruncate;
}
@@ -133,10 +138,10 @@ public class SegmentedRaftLogCache {
return toDelete;
}
- TruncationSegments(SegmentFileInfo toTruncate,
- List<SegmentFileInfo> toDelete) {
- this.toDelete = SegmentFileInfo.toSortedArray(toDelete);
+ TruncationSegments(String reason, SegmentFileInfo toTruncate, List<SegmentFileInfo> toDelete) {
+ this.reason = reason;
this.toTruncate = toTruncate;
+ this.toDelete = SegmentFileInfo.toSortedArray(toDelete);
}
long maxEndIndex() {
@@ -152,8 +157,9 @@ public class SegmentedRaftLogCache {
@Override
public String toString() {
- return "toTruncate: " + toTruncate
- + "\n toDelete: " + Arrays.toString(toDelete);
+ return reason
+ + "\n toTruncate: " + toTruncate
+ + "\n toDelete: " + Arrays.toString(toDelete);
}
}
@@ -297,6 +303,7 @@ public class SegmentedRaftLogCache {
}
TruncationSegments truncate(long index, LogSegment openSegment, Runnable clearOpenSegment) {
+ final String reason = "truncate(" + index + ")";
try(AutoCloseableLock writeLock = writeLock()) {
final int segmentIndex = binarySearch(index);
if (segmentIndex == -segments.size() - 1) {
@@ -305,7 +312,7 @@ public class SegmentedRaftLogCache {
if (index == openSegment.getStartIndex()) {
// the open segment should be deleted
final SegmentFileInfo deleted = deleteOpenSegment(openSegment, clearOpenSegment);
- return new TruncationSegments(null, Collections.singletonList(deleted));
+ return new TruncationSegments(reason, null, Collections.singletonList(deleted));
} else {
openSegment.truncate(index);
Preconditions.assertTrue(!openSegment.isOpen(),
@@ -315,7 +322,7 @@ public class SegmentedRaftLogCache {
segments.add(openSegment);
sizeInBytes += openSegment.getTotalFileSize();
clearOpenSegment.run();
- return new TruncationSegments(info, Collections.emptyList());
+ return new TruncationSegments(reason, info, Collections.emptyList());
}
}
} else if (segmentIndex >= 0) {
@@ -340,7 +347,7 @@ public class SegmentedRaftLogCache {
}
SegmentFileInfo t = ts.numOfEntries() == 0? null:
new SegmentFileInfo(ts.getStartIndex(), oldEnd, false, ts.getTotalFileSize(), ts.getEndIndex());
- return new TruncationSegments(t, list);
+ return new TruncationSegments(reason, t, list);
}
return null;
}
@@ -373,7 +380,7 @@ public class SegmentedRaftLogCache {
throw new IllegalStateException("Unexpected gap in segments: binarySearch(" + index + ") returns "
+ segmentIndex + ", segments=" + segments);
}
- return list.isEmpty() ? null : new TruncationSegments(null, list);
+ return list.isEmpty() ? null : new TruncationSegments("purge(" + index + ")", null, list);
}
}
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogInputStream.java b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogInputStream.java
index 481f837f5..050c472dd 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogInputStream.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogInputStream.java
@@ -33,6 +33,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.apache.ratis.server.raftlog.RaftLog.INVALID_LOG_INDEX;
+import static org.apache.ratis.server.raftlog.RaftLog.LEAST_VALID_LOG_INDEX;
public class SegmentedRaftLogInputStream implements Closeable {
static final Logger LOG = LoggerFactory.getLogger(SegmentedRaftLogInputStream.class);
@@ -62,27 +63,17 @@ public class SegmentedRaftLogInputStream implements Closeable {
}
private final File logFile;
- private final long startIndex;
- private final long endIndex;
- private final boolean isOpen;
+ private final LogSegmentStartEnd startEnd;
private final OpenCloseState state;
private SegmentedRaftLogReader reader;
private final SizeInBytes maxOpSize;
private final SegmentedRaftLogMetrics raftLogMetrics;
- SegmentedRaftLogInputStream(File log, long startIndex, long endIndex, boolean isOpen,
+ SegmentedRaftLogInputStream(File log, LogSegmentStartEnd startEnd,
SizeInBytes maxOpSize, SegmentedRaftLogMetrics raftLogMetrics) {
this.maxOpSize = maxOpSize;
- if (isOpen) {
- Preconditions.assertTrue(endIndex == INVALID_LOG_INDEX);
- } else {
- Preconditions.assertTrue(endIndex >= startIndex);
- }
-
this.logFile = log;
- this.startIndex = startIndex;
- this.endIndex = endIndex;
- this.isOpen = isOpen;
+ this.startEnd = startEnd;
this.state = new OpenCloseState(getName());
this.raftLogMetrics = raftLogMetrics;
}
@@ -104,14 +95,6 @@ public class SegmentedRaftLogInputStream implements Closeable {
}
}
- long getStartIndex() {
- return startIndex;
- }
-
- long getEndIndex() {
- return endIndex;
- }
-
String getName() {
return logFile.getName();
}
@@ -131,7 +114,7 @@ public class SegmentedRaftLogInputStream implements Closeable {
final LogEntryProto entry = reader.readEntry();
if (entry != null) {
long index = entry.getIndex();
- if (!isOpen() && index >= endIndex) {
+ if (!startEnd.isOpen() && index >= startEnd.getEndIndex()) {
/*
* The end index may be derived from the segment recovery
* process. It is possible that we still have some uncleaned garbage
@@ -139,8 +122,8 @@ public class SegmentedRaftLogInputStream implements Closeable {
*/
long skipAmt = logFile.length() - reader.getPos();
if (skipAmt > 0) {
- LOG.debug("skipping {} bytes at the end of log '{}': reached" +
- " entry {} out of {}", skipAmt, getName(), index, endIndex);
+ LOG.info("Skipping {} bytes at the end of log '{}': reached entry {} out of [{}]",
+ skipAmt, getName(), index, startEnd);
reader.skipFully(skipAmt);
}
}
@@ -172,10 +155,6 @@ public class SegmentedRaftLogInputStream implements Closeable {
}
}
- boolean isOpen() {
- return isOpen;
- }
-
@Override
public String toString() {
return getName();
@@ -188,24 +167,18 @@ public class SegmentedRaftLogInputStream implements Closeable {
* ID. The file portion beyond this ID is
* potentially being updated.
* @return Result of the validation
- * @throws IOException
*/
static LogValidation scanEditLog(File file, long maxTxIdToScan, SizeInBytes maxOpSize)
throws IOException {
- SegmentedRaftLogInputStream in;
- try {
- in = new SegmentedRaftLogInputStream(file, INVALID_LOG_INDEX, INVALID_LOG_INDEX, false, maxOpSize, null);
- // read the header, initialize the inputstream
- in.init();
- } catch (EOFException e) {
- LOG.warn("Log file " + file + " has no valid header", e);
- return new LogValidation(0, INVALID_LOG_INDEX, true);
- }
-
- try {
+ final LogSegmentStartEnd startEnd = LogSegmentStartEnd.valueOf(LEAST_VALID_LOG_INDEX);
+ try(SegmentedRaftLogInputStream in = new SegmentedRaftLogInputStream(file, startEnd, maxOpSize, null)) {
+ try {
+ in.init();
+ } catch (EOFException e) {
+ LOG.warn("Invalid header for RaftLog segment {}", file, e);
+ return new LogValidation(0, INVALID_LOG_INDEX, true);
+ }
return scanEditLog(in, maxTxIdToScan);
- } finally {
- IOUtils.cleanup(LOG, in);
}
}
diff --git a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogWorker.java b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogWorker.java
index 68266b417..a8482e71b 100644
--- a/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogWorker.java
+++ b/ratis-server/src/main/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogWorker.java
@@ -46,6 +46,7 @@ import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
+import java.nio.file.Path;
import java.util.LinkedList;
import java.util.Objects;
import java.util.Optional;
@@ -476,7 +477,8 @@ class SegmentedRaftLogWorker {
if (segments.getToDelete() != null) {
try(UncheckedAutoCloseable ignored = raftLogMetrics.startPurgeTimer()) {
for (SegmentFileInfo fileInfo : segments.getToDelete()) {
- FileUtils.deleteFile(fileInfo.getFile(storage));
+ final Path deleted = FileUtils.deleteFile(fileInfo.getFile(storage));
+ LOG.info("{}: Purged RaftLog segment: info={}, path={}", name, fileInfo, deleted);
}
}
}
@@ -568,8 +570,8 @@ class SegmentedRaftLogWorker {
}
}
- File getFile(long startIndex, Long endIndex) {
- return LogSegmentStartEnd.valueOf(startIndex, endIndex).getFile(storage);
+ private File getFile(LogSegmentStartEnd startEnd) {
+ return startEnd.getFile(storage);
}
private class FinalizeLogSegment extends Task {
@@ -586,19 +588,20 @@ class SegmentedRaftLogWorker {
public void execute() throws IOException {
freeSegmentedRaftLogOutputStream();
- final File openFile = getFile(startIndex, null);
+ final LogSegmentStartEnd openStartEnd = LogSegmentStartEnd.valueOf(startIndex);
+ final File openFile = getFile(openStartEnd);
Preconditions.assertTrue(openFile.exists(),
() -> name + ": File " + openFile + " to be rolled does not exist");
if (endIndex - startIndex + 1 > 0) {
// finalize the current open segment
- final File dstFile = getFile(startIndex, endIndex);
+ final File dstFile = getFile(LogSegmentStartEnd.valueOf(startIndex, endIndex));
Preconditions.assertTrue(!dstFile.exists());
FileUtils.move(openFile, dstFile);
LOG.info("{}: Rolled log segment from {} to {}", name, openFile, dstFile);
} else { // delete the file of the empty segment
- FileUtils.deleteFile(openFile);
- LOG.info("{}: Deleted empty log segment {}", name, openFile);
+ final Path deleted = FileUtils.deleteFile(openFile);
+ LOG.info("{}: Deleted empty RaftLog segment: startEnd={}, path={}", name, openStartEnd, deleted);
}
updateFlushedIndexIncreasingly();
safeCacheEvictIndex.updateToMax(endIndex, traceIndexChange);
@@ -631,7 +634,7 @@ class SegmentedRaftLogWorker {
@Override
void execute() throws IOException {
- final File openFile = getFile(newStartIndex, null);
+ final File openFile = getFile(LogSegmentStartEnd.valueOf(newStartIndex));
Preconditions.assertTrue(!openFile.exists(), "open file %s exists for %s",
openFile, name);
Preconditions.assertTrue(pendingFlushNum == 0);
@@ -673,8 +676,8 @@ class SegmentedRaftLogWorker {
final File delFile = del.getFile(storage);
Preconditions.assertTrue(delFile.exists(),
"File %s to be deleted does not exist", delFile);
- FileUtils.deleteFile(delFile);
- LOG.info("{}: Deleted log file {}", name, delFile);
+ final Path deleted = FileUtils.deleteFile(delFile);
+ LOG.info("{}: Deleted RaftLog segment for {}: path={}", name, segments.getReason(), deleted);
minStart = Math.min(minStart, del.getStartIndex());
}
if (segments.getToTruncate() == null) {
diff --git a/ratis-server/src/test/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogTestUtils.java b/ratis-server/src/test/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogTestUtils.java
index e242eddf5..473aa0a46 100644
--- a/ratis-server/src/test/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogTestUtils.java
+++ b/ratis-server/src/test/java/org/apache/ratis/server/raftlog/segmented/SegmentedRaftLogTestUtils.java
@@ -17,25 +17,33 @@
*/
package org.apache.ratis.server.raftlog.segmented;
+import org.apache.ratis.server.RaftServer;
import org.apache.ratis.util.SizeInBytes;
import org.apache.ratis.util.Slf4jUtils;
import org.slf4j.event.Level;
import java.io.File;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Collectors;
public interface SegmentedRaftLogTestUtils {
SizeInBytes MAX_OP_SIZE = SizeInBytes.valueOf("32MB");
static SegmentedRaftLogInputStream newSegmentedRaftLogInputStream(File log,
long startIndex, long endIndex, boolean isOpen) {
- return new SegmentedRaftLogInputStream(log, startIndex, endIndex, isOpen, MAX_OP_SIZE, null);
+ final LogSegmentStartEnd startEnd = LogSegmentStartEnd.valueOf(startIndex, endIndex, isOpen);
+ return new SegmentedRaftLogInputStream(log, startEnd, MAX_OP_SIZE, null);
}
static void setRaftLogWorkerLogLevel(Level level) {
Slf4jUtils.setLogLevel(SegmentedRaftLogWorker.LOG, level);
}
- static String getLogFlushTimeMetric(String memberId) {
- return SegmentedRaftLogWorker.class.getName() + "." + memberId + ".flush-time";
+ static List<Path> getOpenLogFiles(RaftServer.Division server) throws Exception {
+ return LogSegmentPath.getLogSegmentPaths(server.getRaftStorage()).stream()
+ .filter(p -> p.getStartEnd().isOpen())
+ .map(LogSegmentPath::getPath)
+ .collect(Collectors.toList());
}
}
diff --git a/ratis-test/src/test/java/org/apache/ratis/server/ServerRestartTests.java b/ratis-test/src/test/java/org/apache/ratis/server/ServerRestartTests.java
index ee93b6885..c9495fdf7 100644
--- a/ratis-test/src/test/java/org/apache/ratis/server/ServerRestartTests.java
+++ b/ratis-test/src/test/java/org/apache/ratis/server/ServerRestartTests.java
@@ -35,8 +35,8 @@ import org.apache.ratis.server.raftlog.RaftLog;
import org.apache.ratis.server.raftlog.RaftLogIOException;
import org.apache.ratis.server.raftlog.segmented.SegmentedRaftLogFormat;
import org.apache.ratis.server.RaftServerConfigKeys.Log;
+import org.apache.ratis.server.raftlog.segmented.SegmentedRaftLogTestUtils;
import org.apache.ratis.server.raftlog.segmented.TestSegmentedRaftLog;
-import org.apache.ratis.server.raftlog.segmented.LogSegmentPath;
import org.apache.ratis.statemachine.impl.SimpleStateMachine4Testing;
import org.apache.ratis.statemachine.StateMachine;
import org.apache.ratis.util.FileUtils;
@@ -63,7 +63,6 @@ import java.util.concurrent.CompletionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
-import java.util.stream.Collectors;
/**
* Test restarting raft peers.
@@ -176,15 +175,8 @@ public abstract class ServerRestartTests<CLUSTER extends MiniRaftCluster>
server.getRaftServer().close();
}
- static List<Path> getOpenLogFiles(RaftServer.Division server) throws Exception {
- return LogSegmentPath.getLogSegmentPaths(server.getRaftStorage()).stream()
- .filter(p -> p.getStartEnd().isOpen())
- .map(LogSegmentPath::getPath)
- .collect(Collectors.toList());
- }
-
static File getOpenLogFile(RaftServer.Division server) throws Exception {
- final List<Path> openLogs = getOpenLogFiles(server);
+ final List<Path> openLogs = SegmentedRaftLogTestUtils.getOpenLogFiles(server);
Assertions.assertEquals(1, openLogs.size());
return openLogs.get(0).toFile();
}
@@ -211,7 +203,7 @@ public abstract class ServerRestartTests<CLUSTER extends MiniRaftCluster>
10, HUNDRED_MILLIS, impl.getId() + "-getOpenLogFile", LOG);
for(int i = 0; i < SegmentedRaftLogFormat.getHeaderLength(); i++) {
assertCorruptedLogHeader(impl.getId(), openLogFile, i, cluster, LOG);
- Assertions.assertTrue(getOpenLogFiles(impl).isEmpty());
+ Assertions.assertTrue(SegmentedRaftLogTestUtils.getOpenLogFiles(impl).isEmpty());
}
}
}
diff --git a/ratis-test/src/test/java/org/apache/ratis/server/raftlog/segmented/TestLogSegment.java b/ratis-test/src/test/java/org/apache/ratis/server/raftlog/segmented/TestLogSegment.java
index 50f9d2382..a95c683c8 100644
--- a/ratis-test/src/test/java/org/apache/ratis/server/raftlog/segmented/TestLogSegment.java
+++ b/ratis-test/src/test/java/org/apache/ratis/server/raftlog/segmented/TestLogSegment.java
@@ -58,6 +58,8 @@ import static org.apache.ratis.server.raftlog.segmented.SegmentedRaftLogTestUtil
* Test basic functionality of {@link LogSegment}
*/
public class TestLogSegment extends BaseTest {
+ public static final LogSegmentStartEnd ZERO_START_NULL_END = LogSegmentStartEnd.valueOf(0);
+
private File storageDir;
private long segmentMaxSize;
private long preallocatedSize;
@@ -173,7 +175,7 @@ public class TestLogSegment extends BaseTest {
final File openSegmentFile = prepareLog(true, 0, 100, 0, isLastEntryPartiallyWritten);
RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
final LogSegment openSegment = LogSegment.loadSegment(storage, openSegmentFile,
- LogSegmentStartEnd.valueOf(0), MAX_OP_SIZE, loadInitial, null, null);
+ ZERO_START_NULL_END, MAX_OP_SIZE, loadInitial, null, null);
final int delta = isLastEntryPartiallyWritten? 1: 0;
checkLogSegment(openSegment, 0, 99 - delta, true, openSegmentFile.length(), 0);
storage.close();
@@ -218,7 +220,7 @@ public class TestLogSegment extends BaseTest {
final File openSegmentFile = prepareLog(true, 0, 100, 0, true);
RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
final LogSegment openSegment = LogSegment.loadSegment(storage, openSegmentFile,
- LogSegmentStartEnd.valueOf(0), MAX_OP_SIZE, true, null, raftLogMetrics);
+ ZERO_START_NULL_END, MAX_OP_SIZE, true, null, raftLogMetrics);
checkLogSegment(openSegment, 0, 98, true, openSegmentFile.length(), 0);
storage.close();
@@ -287,7 +289,7 @@ public class TestLogSegment extends BaseTest {
@Test
public void testPreallocateSegment() throws Exception {
RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
- final File file = LogSegmentStartEnd.valueOf(0).getFile(storage);
+ final File file = ZERO_START_NULL_END.getFile(storage);
final int[] maxSizes = new int[]{1024, 1025, 1024 * 1024 - 1, 1024 * 1024,
1024 * 1024 + 1, 2 * 1024 * 1024 - 1, 2 * 1024 * 1024,
2 * 1024 * 1024 + 1, 8 * 1024 * 1024};
@@ -338,7 +340,7 @@ public class TestLogSegment extends BaseTest {
public void testPreallocationAndAppend() throws Exception {
final SizeInBytes max = SizeInBytes.valueOf(2, TraditionalBinaryPrefix.MEGA);
RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
- final File file = LogSegmentStartEnd.valueOf(0).getFile(storage);
+ final File file = ZERO_START_NULL_END.getFile(storage);
final byte[] content = new byte[1024];
Arrays.fill(content, (byte) 1);
@@ -368,7 +370,7 @@ public class TestLogSegment extends BaseTest {
@Test
public void testZeroSizeInProgressFile() throws Exception {
final RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
- final File file = LogSegmentStartEnd.valueOf(0).getFile(storage);
+ final File file = ZERO_START_NULL_END.getFile(storage);
storage.close();
// create zero size in-progress file
diff --git a/ratis-test/src/test/java/org/apache/ratis/server/raftlog/segmented/TestRaftLogReadWrite.java b/ratis-test/src/test/java/org/apache/ratis/server/raftlog/segmented/TestRaftLogReadWrite.java
index 4f151c733..560091407 100644
--- a/ratis-test/src/test/java/org/apache/ratis/server/raftlog/segmented/TestRaftLogReadWrite.java
+++ b/ratis-test/src/test/java/org/apache/ratis/server/raftlog/segmented/TestRaftLogReadWrite.java
@@ -44,6 +44,8 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import static org.apache.ratis.server.raftlog.segmented.TestLogSegment.ZERO_START_NULL_END;
+
/**
* Test basic functionality of LogReader, SegmentedRaftLogInputStream, and SegmentedRaftLogOutputStream.
*/
@@ -105,7 +107,7 @@ public class TestRaftLogReadWrite extends BaseTest {
@Test
public void testReadWriteLog() throws IOException {
final RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
- final File openSegment = LogSegmentStartEnd.valueOf(0).getFile(storage);
+ final File openSegment = ZERO_START_NULL_END.getFile(storage);
long size = SegmentedRaftLogFormat.getHeaderLength();
final LogEntryProto[] entries = new LogEntryProto[100];
@@ -125,7 +127,7 @@ public class TestRaftLogReadWrite extends BaseTest {
@Test
public void testAppendLog() throws IOException {
final RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
- final File openSegment = LogSegmentStartEnd.valueOf(0).getFile(storage);
+ final File openSegment = ZERO_START_NULL_END.getFile(storage);
LogEntryProto[] entries = new LogEntryProto[200];
try (SegmentedRaftLogOutputStream out = new SegmentedRaftLogOutputStream(openSegment, false,
segmentMaxSize, preallocatedSize, ByteBuffer.allocateDirect(bufferSize))) {
@@ -158,7 +160,7 @@ public class TestRaftLogReadWrite extends BaseTest {
@Test
public void testReadWithPadding() throws IOException {
final RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
- final File openSegment = LogSegmentStartEnd.valueOf(0).getFile(storage);
+ final File openSegment = ZERO_START_NULL_END.getFile(storage);
long size = SegmentedRaftLogFormat.getHeaderLength();
LogEntryProto[] entries = new LogEntryProto[100];
@@ -187,7 +189,7 @@ public class TestRaftLogReadWrite extends BaseTest {
@Test
public void testReadWithCorruptPadding() throws IOException {
final RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
- final File openSegment = LogSegmentStartEnd.valueOf(0).getFile(storage);
+ final File openSegment = ZERO_START_NULL_END.getFile(storage);
LogEntryProto[] entries = new LogEntryProto[10];
final SegmentedRaftLogOutputStream out = new SegmentedRaftLogOutputStream(openSegment, false,
@@ -236,7 +238,7 @@ public class TestRaftLogReadWrite extends BaseTest {
@Test
public void testReadWithEntryCorruption() throws IOException {
RaftStorage storage = RaftStorageTestUtils.newRaftStorage(storageDir);
- final File openSegment = LogSegmentStartEnd.valueOf(0).getFile(storage);
+ final File openSegment = ZERO_START_NULL_END.getFile(storage);
try (SegmentedRaftLogOutputStream out = new SegmentedRaftLogOutputStream(openSegment, false,
segmentMaxSize, preallocatedSize, ByteBuffer.allocateDirect(bufferSize))) {
for (int i = 0; i < 100; i++) {