From 62f3462cc8419eacddeb0d66d49ddeb3eb38f365 Mon Sep 17 00:00:00 2001 From: Ryan Ernst Date: Mon, 4 Oct 2021 11:40:01 -0700 Subject: [PATCH] Revert "Remove multiple paths from elasticsearch-node tool (#72351)" This reverts commit 619a011782cce1fadbfabf45b0f0dce75c8a155f. relates #78525 relates #71205 --- .../RemoveCorruptedShardDataCommandIT.java | 2 +- .../coordination/DetachClusterCommand.java | 4 +- .../ElasticsearchNodeCommand.java | 19 ++++++---- .../coordination/RemoveCustomsCommand.java | 4 +- .../coordination/RemoveSettingsCommand.java | 4 +- .../UnsafeBootstrapMasterCommand.java | 4 +- .../env/NodeRepurposeCommand.java | 29 +++++++------- .../env/OverrideNodeVersionCommand.java | 9 +++-- .../RemoveCorruptedShardDataCommand.java | 29 +++++++------- .../env/OverrideNodeVersionCommandTests.java | 38 +++++++++---------- .../RemoveCorruptedShardDataCommandTests.java | 17 +++++---- 11 files changed, 85 insertions(+), 74 deletions(-) diff --git a/server/src/internalClusterTest/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommandIT.java b/server/src/internalClusterTest/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommandIT.java index c58cf04155e0f..47b08712a7118 100644 --- a/server/src/internalClusterTest/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommandIT.java +++ b/server/src/internalClusterTest/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommandIT.java @@ -568,7 +568,7 @@ public void testResolvePath() throws Exception { final Path indexPath = indexPathByNodeName.get(nodeName); final OptionSet options = parser.parse("--dir", indexPath.toAbsolutePath().toString()); command.findAndProcessShardPath(options, environmentByNodeName.get(nodeName), - environmentByNodeName.get(nodeName).dataFile(), + new Path[] { environmentByNodeName.get(nodeName).dataFile() }, state, shardPath -> assertThat(shardPath.resolveIndex(), equalTo(indexPath))); } } diff --git a/server/src/main/java/org/elasticsearch/cluster/coordination/DetachClusterCommand.java b/server/src/main/java/org/elasticsearch/cluster/coordination/DetachClusterCommand.java index c03773703169e..035d41b8d1042 100644 --- a/server/src/main/java/org/elasticsearch/cluster/coordination/DetachClusterCommand.java +++ b/server/src/main/java/org/elasticsearch/cluster/coordination/DetachClusterCommand.java @@ -38,8 +38,8 @@ public DetachClusterCommand() { @Override - protected void processNodePaths(Terminal terminal, Path dataPath, OptionSet options, Environment env) throws IOException { - final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPath); + protected void processNodePaths(Terminal terminal, Path[] dataPaths, OptionSet options, Environment env) throws IOException { + final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPaths); terminal.println(Terminal.Verbosity.VERBOSE, "Loading cluster state"); final ClusterState oldClusterState = loadTermAndClusterState(persistedClusterStateService, env).v2(); diff --git a/server/src/main/java/org/elasticsearch/cluster/coordination/ElasticsearchNodeCommand.java b/server/src/main/java/org/elasticsearch/cluster/coordination/ElasticsearchNodeCommand.java index 9c18fa447cebc..90bca9bc230b6 100644 --- a/server/src/main/java/org/elasticsearch/cluster/coordination/ElasticsearchNodeCommand.java +++ b/server/src/main/java/org/elasticsearch/cluster/coordination/ElasticsearchNodeCommand.java @@ -40,6 +40,7 @@ import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import java.util.Arrays; import java.util.EnumSet; import java.util.Map; @@ -99,14 +100,14 @@ public ElasticsearchNodeCommand(String description) { super(description); } - public static PersistedClusterStateService createPersistedClusterStateService(Settings settings, Path dataPath) throws IOException { - final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(dataPath); + public static PersistedClusterStateService createPersistedClusterStateService(Settings settings, Path... dataPaths) throws IOException { + final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(dataPaths); if (nodeMetadata == null) { throw new ElasticsearchException(NO_NODE_METADATA_FOUND_MSG); } String nodeId = nodeMetadata.nodeId(); - return new PersistedClusterStateService(new Path[] { dataPath }, nodeId, namedXContentRegistry, BigArrays.NON_RECYCLING_INSTANCE, + return new PersistedClusterStateService(dataPaths, nodeId, namedXContentRegistry, BigArrays.NON_RECYCLING_INSTANCE, new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS), () -> 0L); } @@ -133,7 +134,7 @@ protected void processNodePaths(Terminal terminal, OptionSet options, Environmen if (dataPath == null) { throw new ElasticsearchException(NO_NODE_FOLDER_FOUND_MSG); } - processNodePaths(terminal, dataPath.path, options, env); + processNodePaths(terminal, new Path[] { dataPath.path }, options, env); } catch (LockObtainFailedException e) { throw new ElasticsearchException(FAILED_TO_OBTAIN_NODE_LOCK_MSG, e); } @@ -169,14 +170,18 @@ protected boolean validateBeforeLock(Terminal terminal, Environment env) { /** * Process the paths. Locks for the paths is held during this method invocation. * @param terminal the terminal to use for messages - * @param dataPath the path of the node to process + * @param dataPaths the paths of the node to process * @param options the command line options * @param env the env of the node to process */ - protected abstract void processNodePaths(Terminal terminal, Path dataPath, OptionSet options, Environment env) + protected abstract void processNodePaths(Terminal terminal, Path[] dataPaths, OptionSet options, Environment env) throws IOException, UserException; - protected static NodeEnvironment.NodePath createNodePath(Path path) { + protected NodeEnvironment.NodePath[] toNodePaths(Path[] dataPaths) { + return Arrays.stream(dataPaths).map(ElasticsearchNodeCommand::createNodePath).toArray(NodeEnvironment.NodePath[]::new); + } + + private static NodeEnvironment.NodePath createNodePath(Path path) { try { return new NodeEnvironment.NodePath(path); } catch (IOException e) { diff --git a/server/src/main/java/org/elasticsearch/cluster/coordination/RemoveCustomsCommand.java b/server/src/main/java/org/elasticsearch/cluster/coordination/RemoveCustomsCommand.java index bd82b0e85aaa0..814838143d0cf 100644 --- a/server/src/main/java/org/elasticsearch/cluster/coordination/RemoveCustomsCommand.java +++ b/server/src/main/java/org/elasticsearch/cluster/coordination/RemoveCustomsCommand.java @@ -44,14 +44,14 @@ public RemoveCustomsCommand() { } @Override - protected void processNodePaths(Terminal terminal, Path dataPath, OptionSet options, Environment env) + protected void processNodePaths(Terminal terminal, Path[] dataPaths, OptionSet options, Environment env) throws IOException, UserException { final List customsToRemove = arguments.values(options); if (customsToRemove.isEmpty()) { throw new UserException(ExitCodes.USAGE, "Must supply at least one custom metadata name to remove"); } - final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPath); + final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPaths); terminal.println(Terminal.Verbosity.VERBOSE, "Loading cluster state"); final Tuple termAndClusterState = loadTermAndClusterState(persistedClusterStateService, env); diff --git a/server/src/main/java/org/elasticsearch/cluster/coordination/RemoveSettingsCommand.java b/server/src/main/java/org/elasticsearch/cluster/coordination/RemoveSettingsCommand.java index b32769814aee0..297b75d2adc19 100644 --- a/server/src/main/java/org/elasticsearch/cluster/coordination/RemoveSettingsCommand.java +++ b/server/src/main/java/org/elasticsearch/cluster/coordination/RemoveSettingsCommand.java @@ -44,14 +44,14 @@ public RemoveSettingsCommand() { } @Override - protected void processNodePaths(Terminal terminal, Path dataPath, OptionSet options, Environment env) + protected void processNodePaths(Terminal terminal, Path[] dataPaths, OptionSet options, Environment env) throws IOException, UserException { final List settingsToRemove = arguments.values(options); if (settingsToRemove.isEmpty()) { throw new UserException(ExitCodes.USAGE, "Must supply at least one setting to remove"); } - final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPath); + final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPaths); terminal.println(Terminal.Verbosity.VERBOSE, "Loading cluster state"); final Tuple termAndClusterState = loadTermAndClusterState(persistedClusterStateService, env); diff --git a/server/src/main/java/org/elasticsearch/cluster/coordination/UnsafeBootstrapMasterCommand.java b/server/src/main/java/org/elasticsearch/cluster/coordination/UnsafeBootstrapMasterCommand.java index eb1b1c5f04118..c1a50aa75ff7b 100644 --- a/server/src/main/java/org/elasticsearch/cluster/coordination/UnsafeBootstrapMasterCommand.java +++ b/server/src/main/java/org/elasticsearch/cluster/coordination/UnsafeBootstrapMasterCommand.java @@ -69,8 +69,8 @@ protected boolean validateBeforeLock(Terminal terminal, Environment env) { return true; } - protected void processNodePaths(Terminal terminal, Path dataPath, OptionSet options, Environment env) throws IOException { - final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPath); + protected void processNodePaths(Terminal terminal, Path[] dataPaths, OptionSet options, Environment env) throws IOException { + final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPaths); final Tuple state = loadTermAndClusterState(persistedClusterStateService, env); final ClusterState oldClusterState = state.v2(); diff --git a/server/src/main/java/org/elasticsearch/env/NodeRepurposeCommand.java b/server/src/main/java/org/elasticsearch/env/NodeRepurposeCommand.java index f331f287715c6..9b92638a440f8 100644 --- a/server/src/main/java/org/elasticsearch/env/NodeRepurposeCommand.java +++ b/server/src/main/java/org/elasticsearch/env/NodeRepurposeCommand.java @@ -30,6 +30,7 @@ import java.util.List; import java.util.Set; import java.util.stream.Collectors; +import java.util.stream.Stream; import java.util.stream.StreamSupport; import static org.elasticsearch.env.NodeEnvironment.INDICES_FOLDER; @@ -62,28 +63,28 @@ protected boolean validateBeforeLock(Terminal terminal, Environment env) { } @Override - protected void processNodePaths(Terminal terminal, Path dataPath, OptionSet options, Environment env) throws IOException { + protected void processNodePaths(Terminal terminal, Path[] dataPaths, OptionSet options, Environment env) throws IOException { assert DiscoveryNode.canContainData(env.settings()) == false; if (DiscoveryNode.isMasterNode(env.settings()) == false) { - processNoMasterNoDataNode(terminal, dataPath, env); + processNoMasterNoDataNode(terminal, dataPaths, env); } else { - processMasterNoDataNode(terminal, dataPath, env); + processMasterNoDataNode(terminal, dataPaths, env); } } - private void processNoMasterNoDataNode(Terminal terminal, Path dataPath, Environment env) throws IOException { - NodeEnvironment.NodePath nodePath = createNodePath(dataPath); + private void processNoMasterNoDataNode(Terminal terminal, Path[] dataPaths, Environment env) throws IOException { + NodeEnvironment.NodePath[] nodePaths = toNodePaths(dataPaths); terminal.println(Terminal.Verbosity.VERBOSE, "Collecting shard data paths"); - List shardDataPaths = NodeEnvironment.collectShardDataPaths(nodePath); + List shardDataPaths = NodeEnvironment.collectShardDataPaths(nodePaths[0]); terminal.println(Terminal.Verbosity.VERBOSE, "Collecting index metadata paths"); - List indexMetadataPaths = NodeEnvironment.collectIndexMetadataPaths(nodePath); + List indexMetadataPaths = NodeEnvironment.collectIndexMetadataPaths(nodePaths[0]); Set indexPaths = uniqueParentPaths(shardDataPaths, indexMetadataPaths); - final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPath); + final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPaths); final Metadata metadata = loadClusterState(terminal, env, persistedClusterStateService).metadata(); if (indexPaths.isEmpty() && metadata.indices().isEmpty()) { @@ -105,23 +106,23 @@ private void processNoMasterNoDataNode(Terminal terminal, Path dataPath, Environ removePaths(terminal, indexPaths); // clean-up shard dirs // clean-up all metadata dirs - MetadataStateFormat.deleteMetaState(dataPath); - IOUtils.rm(dataPath.resolve(INDICES_FOLDER)); + MetadataStateFormat.deleteMetaState(dataPaths); + IOUtils.rm(Stream.of(dataPaths).map(path -> path.resolve(INDICES_FOLDER)).toArray(Path[]::new)); terminal.println("Node successfully repurposed to no-master and no-data."); } - private void processMasterNoDataNode(Terminal terminal, Path dataPath, Environment env) throws IOException { - NodeEnvironment.NodePath nodePath = createNodePath(dataPath); + private void processMasterNoDataNode(Terminal terminal, Path[] dataPaths, Environment env) throws IOException { + NodeEnvironment.NodePath[] nodePaths = toNodePaths(dataPaths); terminal.println(Terminal.Verbosity.VERBOSE, "Collecting shard data paths"); - List shardDataPaths = NodeEnvironment.collectShardDataPaths(nodePath); + List shardDataPaths = NodeEnvironment.collectShardDataPaths(nodePaths[0]); if (shardDataPaths.isEmpty()) { terminal.println(NO_SHARD_DATA_TO_CLEAN_UP_FOUND); return; } - final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPath); + final PersistedClusterStateService persistedClusterStateService = createPersistedClusterStateService(env.settings(), dataPaths); final Metadata metadata = loadClusterState(terminal, env, persistedClusterStateService).metadata(); diff --git a/server/src/main/java/org/elasticsearch/env/OverrideNodeVersionCommand.java b/server/src/main/java/org/elasticsearch/env/OverrideNodeVersionCommand.java index 886a2b6add8b7..ce108367d4c9d 100644 --- a/server/src/main/java/org/elasticsearch/env/OverrideNodeVersionCommand.java +++ b/server/src/main/java/org/elasticsearch/env/OverrideNodeVersionCommand.java @@ -17,6 +17,7 @@ import java.io.IOException; import java.nio.file.Path; +import java.util.Arrays; public class OverrideNodeVersionCommand extends ElasticsearchNodeCommand { private static final String TOO_NEW_MESSAGE = @@ -57,9 +58,9 @@ public OverrideNodeVersionCommand() { } @Override - protected void processNodePaths(Terminal terminal, Path dataPath, OptionSet options, Environment env) throws IOException { - final Path nodePath = createNodePath(dataPath).path; - final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePath); + protected void processNodePaths(Terminal terminal, Path[] dataPaths, OptionSet options, Environment env) throws IOException { + final Path[] nodePaths = Arrays.stream(toNodePaths(dataPaths)).map(p -> p.path).toArray(Path[]::new); + final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePaths); if (nodeMetadata == null) { throw new ElasticsearchException(NO_METADATA_MESSAGE); } @@ -77,7 +78,7 @@ protected void processNodePaths(Terminal terminal, Path dataPath, OptionSet opti .replace("V_NEW", nodeMetadata.nodeVersion().toString()) .replace("V_CUR", Version.CURRENT.toString())); - PersistedClusterStateService.overrideVersion(Version.CURRENT, dataPath); + PersistedClusterStateService.overrideVersion(Version.CURRENT, dataPaths); terminal.println(SUCCESS_MESSAGE); } diff --git a/server/src/main/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommand.java b/server/src/main/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommand.java index 929e301fd9d5f..b3e537cb34e08 100644 --- a/server/src/main/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommand.java +++ b/server/src/main/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommand.java @@ -108,7 +108,7 @@ protected Path getPath(String dirValue) { return PathUtils.get(dirValue, "", ""); } - protected void findAndProcessShardPath(OptionSet options, Environment environment, Path dataPath, ClusterState clusterState, + protected void findAndProcessShardPath(OptionSet options, Environment environment, Path[] dataPaths, ClusterState clusterState, CheckedConsumer consumer) throws IOException { final Settings settings = environment.settings(); @@ -154,15 +154,18 @@ protected void findAndProcessShardPath(OptionSet options, Environment environmen final Index index = indexMetadata.getIndex(); final ShardId shId = new ShardId(index, shardId); - final Path shardPathLocation = dataPath - .resolve(NodeEnvironment.INDICES_FOLDER) - .resolve(index.getUUID()) - .resolve(Integer.toString(shId.id())); - if (Files.exists(shardPathLocation)) { - final ShardPath shardPath = ShardPath.loadShardPath(logger, shId, indexSettings.customDataPath(), - new Path[]{shardPathLocation}, dataPath); - if (shardPath != null) { - consumer.accept(shardPath); + for (Path dataPath : dataPaths) { + final Path shardPathLocation = dataPath + .resolve(NodeEnvironment.INDICES_FOLDER) + .resolve(index.getUUID()) + .resolve(Integer.toString(shId.id())); + if (Files.exists(shardPathLocation)) { + final ShardPath shardPath = ShardPath.loadShardPath(logger, shId, indexSettings.customDataPath(), + new Path[]{shardPathLocation}, dataPath); + if (shardPath != null) { + consumer.accept(shardPath); + return; + } } } } @@ -225,13 +228,13 @@ private void warnAboutIndexBackup(Terminal terminal) { // Visible for testing @Override - public void processNodePaths(Terminal terminal, Path dataPath, OptionSet options, Environment environment) throws IOException { + public void processNodePaths(Terminal terminal, Path[] dataPaths, OptionSet options, Environment environment) throws IOException { warnAboutIndexBackup(terminal); final ClusterState clusterState = - loadTermAndClusterState(createPersistedClusterStateService(environment.settings(), dataPath), environment).v2(); + loadTermAndClusterState(createPersistedClusterStateService(environment.settings(), dataPaths), environment).v2(); - findAndProcessShardPath(options, environment, dataPath, clusterState, shardPath -> { + findAndProcessShardPath(options, environment, dataPaths, clusterState, shardPath -> { final Path indexPath = shardPath.resolveIndex(); final Path translogPath = shardPath.resolveTranslog(); if (Files.exists(translogPath) == false || Files.isDirectory(translogPath) == false) { diff --git a/server/src/test/java/org/elasticsearch/env/OverrideNodeVersionCommandTests.java b/server/src/test/java/org/elasticsearch/env/OverrideNodeVersionCommandTests.java index 9d9ee6debaf39..7bc3e81ae522c 100644 --- a/server/src/test/java/org/elasticsearch/env/OverrideNodeVersionCommandTests.java +++ b/server/src/test/java/org/elasticsearch/env/OverrideNodeVersionCommandTests.java @@ -33,7 +33,7 @@ public class OverrideNodeVersionCommandTests extends ESTestCase { private Environment environment; - private Path nodePath; + private Path[] nodePaths; private String nodeId; private final OptionSet noOptions = new OptionParser().parse(); @@ -42,10 +42,10 @@ public void createNodePaths() throws IOException { final Settings settings = buildEnvSettings(Settings.EMPTY); environment = TestEnvironment.newEnvironment(settings); try (NodeEnvironment nodeEnvironment = new NodeEnvironment(settings, environment)) { - nodePath = nodeEnvironment.nodeDataPath(); + nodePaths = new Path[] { nodeEnvironment.nodeDataPath() }; nodeId = nodeEnvironment.nodeId(); - try (PersistedClusterStateService.Writer writer = new PersistedClusterStateService(new Path[] { nodePath }, nodeId, + try (PersistedClusterStateService.Writer writer = new PersistedClusterStateService(nodePaths, nodeId, xContentRegistry(), BigArrays.NON_RECYCLING_INSTANCE, new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS), () -> 0L).createWriter()) { writer.writeFullStateAndCommit(1L, ClusterState.builder(ClusterName.DEFAULT).metadata(Metadata.builder() @@ -57,7 +57,7 @@ public void createNodePaths() throws IOException { @After public void checkClusterStateIntact() throws IOException { - assertTrue(Metadata.SETTING_READ_ONLY_SETTING.get(new PersistedClusterStateService(new Path[] { nodePath }, nodeId, + assertTrue(Metadata.SETTING_READ_ONLY_SETTING.get(new PersistedClusterStateService(nodePaths, nodeId, xContentRegistry(), BigArrays.NON_RECYCLING_INSTANCE, new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS), () -> 0L) .loadBestOnDiskState().metadata.persistentSettings())); @@ -67,17 +67,17 @@ public void testFailsOnEmptyPath() { final Path emptyPath = createTempDir(); final MockTerminal mockTerminal = new MockTerminal(); final ElasticsearchException elasticsearchException = expectThrows(ElasticsearchException.class, () -> - new OverrideNodeVersionCommand().processNodePaths(mockTerminal, emptyPath, noOptions, environment)); + new OverrideNodeVersionCommand().processNodePaths(mockTerminal, new Path[]{emptyPath}, noOptions, environment)); assertThat(elasticsearchException.getMessage(), equalTo(OverrideNodeVersionCommand.NO_METADATA_MESSAGE)); expectThrows(IllegalStateException.class, () -> mockTerminal.readText("")); } public void testFailsIfUnnecessary() throws IOException { final Version nodeVersion = Version.fromId(between(Version.CURRENT.minimumIndexCompatibilityVersion().id, Version.CURRENT.id)); - PersistedClusterStateService.overrideVersion(nodeVersion, nodePath); + PersistedClusterStateService.overrideVersion(nodeVersion, nodePaths); final MockTerminal mockTerminal = new MockTerminal(); final ElasticsearchException elasticsearchException = expectThrows(ElasticsearchException.class, () -> - new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePath, noOptions, environment)); + new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePaths, noOptions, environment)); assertThat(elasticsearchException.getMessage(), allOf( containsString("compatible with current version"), containsString(Version.CURRENT.toString()), @@ -87,11 +87,11 @@ public void testFailsIfUnnecessary() throws IOException { public void testWarnsIfTooOld() throws Exception { final Version nodeVersion = NodeMetadataTests.tooOldVersion(); - PersistedClusterStateService.overrideVersion(nodeVersion, nodePath); + PersistedClusterStateService.overrideVersion(nodeVersion, nodePaths); final MockTerminal mockTerminal = new MockTerminal(); mockTerminal.addTextInput("n\n"); final ElasticsearchException elasticsearchException = expectThrows(ElasticsearchException.class, () -> - new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePath, noOptions, environment)); + new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePaths, noOptions, environment)); assertThat(elasticsearchException.getMessage(), equalTo("aborted by user")); assertThat(mockTerminal.getOutput(), allOf( containsString("too old"), @@ -101,17 +101,17 @@ public void testWarnsIfTooOld() throws Exception { containsString(nodeVersion.toString()))); expectThrows(IllegalStateException.class, () -> mockTerminal.readText("")); - final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePath); + final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePaths); assertThat(nodeMetadata.nodeVersion(), equalTo(nodeVersion)); } public void testWarnsIfTooNew() throws Exception { final Version nodeVersion = NodeMetadataTests.tooNewVersion(); - PersistedClusterStateService.overrideVersion(nodeVersion, nodePath); + PersistedClusterStateService.overrideVersion(nodeVersion, nodePaths); final MockTerminal mockTerminal = new MockTerminal(); mockTerminal.addTextInput(randomFrom("yy", "Yy", "n", "yes", "true", "N", "no")); final ElasticsearchException elasticsearchException = expectThrows(ElasticsearchException.class, () -> - new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePath, noOptions, environment)); + new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePaths, noOptions, environment)); assertThat(elasticsearchException.getMessage(), equalTo("aborted by user")); assertThat(mockTerminal.getOutput(), allOf( containsString("data loss"), @@ -120,16 +120,16 @@ public void testWarnsIfTooNew() throws Exception { containsString(nodeVersion.toString()))); expectThrows(IllegalStateException.class, () -> mockTerminal.readText("")); - final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePath); + final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePaths); assertThat(nodeMetadata.nodeVersion(), equalTo(nodeVersion)); } public void testOverwritesIfTooOld() throws Exception { final Version nodeVersion = NodeMetadataTests.tooOldVersion(); - PersistedClusterStateService.overrideVersion(nodeVersion, nodePath); + PersistedClusterStateService.overrideVersion(nodeVersion, nodePaths); final MockTerminal mockTerminal = new MockTerminal(); mockTerminal.addTextInput(randomFrom("y", "Y")); - new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePath, noOptions, environment); + new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePaths, noOptions, environment); assertThat(mockTerminal.getOutput(), allOf( containsString("too old"), containsString("data loss"), @@ -139,16 +139,16 @@ public void testOverwritesIfTooOld() throws Exception { containsString(OverrideNodeVersionCommand.SUCCESS_MESSAGE))); expectThrows(IllegalStateException.class, () -> mockTerminal.readText("")); - final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePath); + final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePaths); assertThat(nodeMetadata.nodeVersion(), equalTo(Version.CURRENT)); } public void testOverwritesIfTooNew() throws Exception { final Version nodeVersion = NodeMetadataTests.tooNewVersion(); - PersistedClusterStateService.overrideVersion(nodeVersion, nodePath); + PersistedClusterStateService.overrideVersion(nodeVersion, nodePaths); final MockTerminal mockTerminal = new MockTerminal(); mockTerminal.addTextInput(randomFrom("y", "Y")); - new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePath, noOptions, environment); + new OverrideNodeVersionCommand().processNodePaths(mockTerminal, nodePaths, noOptions, environment); assertThat(mockTerminal.getOutput(), allOf( containsString("data loss"), containsString("You should not use this tool"), @@ -157,7 +157,7 @@ public void testOverwritesIfTooNew() throws Exception { containsString(OverrideNodeVersionCommand.SUCCESS_MESSAGE))); expectThrows(IllegalStateException.class, () -> mockTerminal.readText("")); - final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePath); + final NodeMetadata nodeMetadata = PersistedClusterStateService.nodeMetadata(nodePaths); assertThat(nodeMetadata.nodeVersion(), equalTo(Version.CURRENT)); } } diff --git a/server/src/test/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommandTests.java b/server/src/test/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommandTests.java index 6d7a293f73c66..d926da8fc44dc 100644 --- a/server/src/test/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommandTests.java +++ b/server/src/test/java/org/elasticsearch/index/shard/RemoveCorruptedShardDataCommandTests.java @@ -78,7 +78,7 @@ public class RemoveCorruptedShardDataCommandTests extends IndexShardTestCase { private IndexMetadata indexMetadata; private ClusterState clusterState; private IndexShard indexShard; - private Path dataPath; + private Path[] dataPaths; private Path translogPath; private Path indexPath; @@ -92,15 +92,16 @@ public void setup() throws IOException { routing = TestShardRouting.newShardRouting(shardId, nodeId, true, ShardRoutingState.INITIALIZING, RecoverySource.EmptyStoreRecoverySource.INSTANCE); - dataPath = createTempDir(); + final Path dataDir = createTempDir(); environment = TestEnvironment.newEnvironment(Settings.builder() - .put(Environment.PATH_HOME_SETTING.getKey(), dataPath) - .put(Environment.PATH_DATA_SETTING.getKey(), dataPath.toAbsolutePath().toString()).build()); + .put(Environment.PATH_HOME_SETTING.getKey(), dataDir) + .put(Environment.PATH_DATA_SETTING.getKey(), dataDir.toAbsolutePath().toString()).build()); // create same directory structure as prod does - Files.createDirectories(dataPath); + Files.createDirectories(dataDir); + dataPaths = new Path[] {dataDir}; final Settings settings = Settings.builder() .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT) .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1) @@ -109,7 +110,7 @@ public void setup() throws IOException { .put(IndexMetadata.SETTING_INDEX_UUID, shardId.getIndex().getUUID()) .build(); - final NodeEnvironment.NodePath nodePath = new NodeEnvironment.NodePath(dataPath); + final NodeEnvironment.NodePath nodePath = new NodeEnvironment.NodePath(dataDir); shardPath = new ShardPath(false, nodePath.resolve(shardId), nodePath.resolve(shardId), shardId); // Adding rollover info to IndexMetadata to check that NamedXContentRegistry is properly configured @@ -369,11 +370,11 @@ public void testResolveIndexDirectory() throws Exception { final OptionSet options = parser.parse("--index", shardId.getIndex().getName(), "--shard-id", Integer.toString(shardId.id())); - command.findAndProcessShardPath(options, environment, dataPath, clusterState, + command.findAndProcessShardPath(options, environment, dataPaths, clusterState, shardPath -> assertThat(shardPath.resolveIndex(), equalTo(indexPath))); final OptionSet options2 = parser.parse("--dir", indexPath.toAbsolutePath().toString()); - command.findAndProcessShardPath(options2, environment, dataPath, clusterState, + command.findAndProcessShardPath(options2, environment, dataPaths, clusterState, shardPath -> assertThat(shardPath.resolveIndex(), equalTo(indexPath))); }