honeymoose
/
OpenSearch
mirror of https://github.com/honeymoose/OpenSearch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Spelling: replace interruptable with interruptible (#37049)

This commit is contained in:
Josh Soref 2019-01-02 11:35:53 -05:00 committed by Luca Cavanna
parent c04d5c5468
commit 5d5d5c26bc
4 changed files with 19 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
buildSrc/src/main/java/org/elasticsearch/gradle/testclusters/TestClustersPlugin.java
View File

@ -311,7 +311,7 @@ public class TestClustersPlugin implements Plugin<Project> {
shutdownExecutorService();
});
// When the Daemon is not used, or runs into issues, rely on a shutdown hook
// When the daemon is used, but does not work correctly and eventually dies off (e.x. due to non interruptable
// When the daemon is used, but does not work correctly and eventually dies off (e.x. due to non interruptible
// thread in the build) process will be stopped eventually when the daemon dies.
Runtime.getRuntime().addShutdownHook(new Thread(TestClustersPlugin::shutDownAllClusters));
}

24
server/src/main/java/org/elasticsearch/common/util/CancellableThreads.java
View File

@ -29,7 +29,7 @@ import java.util.Set;
/**
* A utility class for multi threaded operation that needs to be cancellable via interrupts. Every cancellable operation should be
* executed via {@link #execute(Interruptable)}, which will capture the executing thread and make sure it is interrupted in the case
* executed via {@link #execute(Interruptible)}, which will capture the executing thread and make sure it is interrupted in the case
* of cancellation.
*
* Cancellation policy: This class does not support external interruption via <code>Thread#interrupt()</code>. Always use #cancel() instead.
@ -77,33 +77,33 @@ public class CancellableThreads {
}
/**
* run the Interruptable, capturing the executing thread. Concurrent calls to {@link #cancel(String)} will interrupt this thread
* run the Interruptible, capturing the executing thread. Concurrent calls to {@link #cancel(String)} will interrupt this thread
* causing the call to prematurely return.
*
* @param interruptable code to run
* @param interruptible code to run
*/
public void execute(Interruptable interruptable) {
public void execute(Interruptible interruptible) {
try {
executeIO(interruptable);
executeIO(interruptible);
} catch (IOException e) {
assert false : "the passed interruptable can not result in an IOException";
assert false : "the passed interruptible can not result in an IOException";
throw new RuntimeException("unexpected IO exception", e);
}
}
/**
* run the Interruptable, capturing the executing thread. Concurrent calls to {@link #cancel(String)} will interrupt this thread
* run the Interruptible, capturing the executing thread. Concurrent calls to {@link #cancel(String)} will interrupt this thread
* causing the call to prematurely return.
*
* @param interruptable code to run
* @param interruptible code to run
*/
public void executeIO(IOInterruptable interruptable) throws IOException {
public void executeIO(IOInterruptible interruptible) throws IOException {
boolean wasInterrupted = add();
boolean cancelledByExternalInterrupt = false;
RuntimeException runtimeException = null;
IOException ioException = null;
try {
interruptable.run();
interruptible.run();
} catch (InterruptedException | ThreadInterruptedException e) {
// ignore, this interrupt has been triggered by us in #cancel()...
assert cancelled : "Interruption via Thread#interrupt() is unsupported. Use CancellableThreads#cancel() instead";
@ -167,11 +167,11 @@ public class CancellableThreads {
}
public interface Interruptable extends IOInterruptable {
public interface Interruptible extends IOInterruptible {
void run() throws InterruptedException;
}
public interface IOInterruptable {
public interface IOInterruptible {
void run() throws IOException, InterruptedException;
}

4
server/src/main/java/org/elasticsearch/indices/recovery/RecoverySourceHandler.java
View File

@ -237,7 +237,7 @@ public class RecoverySourceHandler {
return targetHistoryUUID != null && targetHistoryUUID.equals(shard.getHistoryUUID());
}
static void runUnderPrimaryPermit(CancellableThreads.Interruptable runnable, String reason,
static void runUnderPrimaryPermit(CancellableThreads.Interruptible runnable, String reason,
IndexShard primary, CancellableThreads cancellableThreads, Logger logger) {
cancellableThreads.execute(() -> {
CompletableFuture<Releasable> permit = new CompletableFuture<>();
@ -563,7 +563,7 @@ public class RecoverySourceHandler {
logger.trace("no translog operations to send");
}
final CancellableThreads.IOInterruptable sendBatch = () -> {
final CancellableThreads.IOInterruptible sendBatch = () -> {
final long targetCheckpoint = recoveryTarget.indexTranslogOperations(
operations, expectedTotalOps, maxSeenAutoIdTimestamp, maxSeqNoOfUpdatesOrDeletes);
targetLocalCheckpoint.set(targetCheckpoint);

8
server/src/test/java/org/elasticsearch/common/util/CancellableThreadsTests.java
View File

@ -18,8 +18,8 @@
*/
package org.elasticsearch.common.util;
import org.elasticsearch.common.util.CancellableThreads.IOInterruptable;
import org.elasticsearch.common.util.CancellableThreads.Interruptable;
import org.elasticsearch.common.util.CancellableThreads.IOInterruptible;
import org.elasticsearch.common.util.CancellableThreads.Interruptible;
import org.elasticsearch.test.ESTestCase;
import org.hamcrest.Matchers;
@ -62,7 +62,7 @@ public class CancellableThreadsTests extends ESTestCase {
}
}
static class TestRunnable implements Interruptable {
static class TestRunnable implements Interruptible {
final TestPlan plan;
final CountDownLatch readyForCancel;
@ -95,7 +95,7 @@ public class CancellableThreadsTests extends ESTestCase {
}
}
static class TestIORunnable implements IOInterruptable {
static class TestIORunnable implements IOInterruptible {
final TestPlan plan;
final CountDownLatch readyForCancel;