mirror of
https://github.com/honeymoose/OpenSearch.git
synced 2025-03-28 02:48:38 +00:00
Fix line lengths in misc other files (#35650)
This commit is contained in:
Gordon Brown
GitHub
parent
953c8586df
commit
4bda469861
buildSrc/src/main/resources
server/src/test/java/org/elasticsearch
similarity
snapshots
AbstractSnapshotIntegTestCase.javaDedicatedClusterSnapshotRestoreIT.javaRepositoriesIT.javaSharedClusterSnapshotRestoreIT.javaSnapshotUtilsTests.java
test
update
validate
versioning
@ -152,16 +152,7 @@
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]search[/\\]suggest[/\\]ContextCompletionSuggestSearchIT.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]search[/\\]suggest[/\\]completion[/\\]CategoryContextMappingTests.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]search[/\\]suggest[/\\]completion[/\\]GeoContextMappingTests.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]similarity[/\\]SimilarityIT.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]snapshots[/\\]AbstractSnapshotIntegTestCase.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]snapshots[/\\]DedicatedClusterSnapshotRestoreIT.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]snapshots[/\\]RepositoriesIT.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]snapshots[/\\]SharedClusterSnapshotRestoreIT.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]snapshots[/\\]SnapshotUtilsTests.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]test[/\\]geo[/\\]RandomShapeGenerator.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]test[/\\]hamcrest[/\\]ElasticsearchGeoAssertions.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]update[/\\]UpdateIT.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]validate[/\\]SimpleValidateQueryIT.java" checks="LineLength" />
|
||||
<suppress files="server[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]versioning[/\\]SimpleVersioningIT.java" checks="LineLength" />
|
||||
|
||||
<!-- Temporarily contains extra-long lines as examples for tests to be written, see https://github.com/elastic/elasticsearch/issues/34829 -->
|
||||
<suppress files="modules[/\\]lang-painless[/\\]src[/\\]test[/\\]java[/\\]org[/\\]elasticsearch[/\\]painless[/\\]ContextExampleTests.java" checks="LineLength" />
|
||||
</suppressions>
|
||||
|
||||
@ -64,11 +64,13 @@ public class SimilarityIT extends ESIntegTestCase {
|
||||
"field2", "the quick brown fox jumped over the lazy dog")
|
||||
.setRefreshPolicy(IMMEDIATE).execute().actionGet();
|
||||
|
||||
SearchResponse bm25SearchResponse = client().prepareSearch().setQuery(matchQuery("field1", "quick brown fox")).execute().actionGet();
|
||||
SearchResponse bm25SearchResponse = client().prepareSearch().setQuery(matchQuery("field1", "quick brown fox"))
|
||||
.execute().actionGet();
|
||||
assertThat(bm25SearchResponse.getHits().getTotalHits(), equalTo(1L));
|
||||
float bm25Score = bm25SearchResponse.getHits().getHits()[0].getScore();
|
||||
|
||||
SearchResponse booleanSearchResponse = client().prepareSearch().setQuery(matchQuery("field2", "quick brown fox")).execute().actionGet();
|
||||
SearchResponse booleanSearchResponse = client().prepareSearch().setQuery(matchQuery("field2", "quick brown fox"))
|
||||
.execute().actionGet();
|
||||
assertThat(booleanSearchResponse.getHits().getTotalHits(), equalTo(1L));
|
||||
float defaultScore = booleanSearchResponse.getHits().getHits()[0].getScore();
|
||||
|
||||
|
||||
@ -106,7 +106,8 @@ public abstract class AbstractSnapshotIntegTestCase extends ESIntegTestCase {
|
||||
public SnapshotInfo waitForCompletion(String repository, String snapshotName, TimeValue timeout) throws InterruptedException {
|
||||
long start = System.currentTimeMillis();
|
||||
while (System.currentTimeMillis() - start < timeout.millis()) {
|
||||
List<SnapshotInfo> snapshotInfos = client().admin().cluster().prepareGetSnapshots(repository).setSnapshots(snapshotName).get().getSnapshots();
|
||||
List<SnapshotInfo> snapshotInfos = client().admin().cluster().prepareGetSnapshots(repository).setSnapshots(snapshotName)
|
||||
.get().getSnapshots();
|
||||
assertThat(snapshotInfos.size(), equalTo(1));
|
||||
if (snapshotInfos.get(0).state().completed()) {
|
||||
// Make sure that snapshot clean up operations are finished
|
||||
|
||||
@ -176,7 +176,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
.execute().actionGet();
|
||||
|
||||
assertThat(client.admin().cluster().prepareState().setRoutingTable(false).setNodes(false).execute().actionGet().getState()
|
||||
.getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1), equalTo(2));
|
||||
.getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1),
|
||||
equalTo(2));
|
||||
|
||||
logger.info("--> create repository");
|
||||
AcknowledgedResponse putRepositoryResponse = client.admin().cluster().preparePutRepository("test-repo")
|
||||
@ -184,10 +185,13 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
|
||||
|
||||
logger.info("--> start snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(0));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").execute().actionGet().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").execute().actionGet()
|
||||
.getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
|
||||
logger.info("--> clean the test persistent setting");
|
||||
client.admin().cluster().prepareUpdateSettings().setPersistentSettings(
|
||||
@ -195,22 +199,26 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
.put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), 1))
|
||||
.execute().actionGet();
|
||||
assertThat(client.admin().cluster().prepareState().setRoutingTable(false).setNodes(false).execute().actionGet().getState()
|
||||
.getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1), equalTo(1));
|
||||
.getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1),
|
||||
equalTo(1));
|
||||
|
||||
stopNode(secondNode);
|
||||
assertThat(client.admin().cluster().prepareHealth().setWaitForNodes("1").get().isTimedOut(), equalTo(false));
|
||||
|
||||
logger.info("--> restore snapshot");
|
||||
try {
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setRestoreGlobalState(true).setWaitForCompletion(true).execute().actionGet();
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setRestoreGlobalState(true)
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
fail("can't restore minimum master nodes");
|
||||
} catch (IllegalArgumentException ex) {
|
||||
assertEquals("illegal value can't update [discovery.zen.minimum_master_nodes] from [1] to [2]", ex.getMessage());
|
||||
assertEquals("cannot set discovery.zen.minimum_master_nodes to more than the current master nodes count [1]", ex.getCause().getMessage());
|
||||
assertEquals("cannot set discovery.zen.minimum_master_nodes to more than the current master nodes count [1]",
|
||||
ex.getCause().getMessage());
|
||||
}
|
||||
logger.info("--> ensure that zen discovery minimum master nodes wasn't restored");
|
||||
assertThat(client.admin().cluster().prepareState().setRoutingTable(false).setNodes(false).execute().actionGet().getState()
|
||||
.getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1), not(equalTo(2)));
|
||||
.getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1),
|
||||
not(equalTo(2)));
|
||||
}
|
||||
|
||||
public void testRestoreCustomMetadata() throws Exception {
|
||||
@ -228,7 +236,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
metadataBuilder.putCustom(NonSnapshottableMetadata.TYPE, new NonSnapshottableMetadata("before_snapshot_ns"));
|
||||
metadataBuilder.putCustom(SnapshottableGatewayMetadata.TYPE, new SnapshottableGatewayMetadata("before_snapshot_s_gw"));
|
||||
metadataBuilder.putCustom(NonSnapshottableGatewayMetadata.TYPE, new NonSnapshottableGatewayMetadata("before_snapshot_ns_gw"));
|
||||
metadataBuilder.putCustom(SnapshotableGatewayNoApiMetadata.TYPE, new SnapshotableGatewayNoApiMetadata("before_snapshot_s_gw_noapi"));
|
||||
metadataBuilder.putCustom(SnapshotableGatewayNoApiMetadata.TYPE,
|
||||
new SnapshotableGatewayNoApiMetadata("before_snapshot_s_gw_noapi"));
|
||||
builder.metaData(metadataBuilder);
|
||||
return builder.build();
|
||||
});
|
||||
@ -239,10 +248,14 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
|
||||
|
||||
logger.info("--> start snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().successfulShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").execute().actionGet().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().successfulShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").execute().actionGet()
|
||||
.getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
|
||||
logger.info("--> change custom persistent metadata");
|
||||
updateClusterState(currentState -> {
|
||||
@ -274,7 +287,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
|
||||
|
||||
logger.info("--> restore snapshot");
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo-2", "test-snap").setRestoreGlobalState(true).setIndices("-*").setWaitForCompletion(true).execute().actionGet();
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo-2", "test-snap").setRestoreGlobalState(true).setIndices("-*")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
|
||||
logger.info("--> make sure old repository wasn't restored");
|
||||
assertThrows(client.admin().cluster().prepareGetRepositories("test-repo"), RepositoryMissingException.class);
|
||||
@ -286,8 +300,10 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
MetaData metaData = clusterState.getMetaData();
|
||||
assertThat(((SnapshottableMetadata) metaData.custom(SnapshottableMetadata.TYPE)).getData(), equalTo("before_snapshot_s"));
|
||||
assertThat(((NonSnapshottableMetadata) metaData.custom(NonSnapshottableMetadata.TYPE)).getData(), equalTo("after_snapshot_ns"));
|
||||
assertThat(((SnapshottableGatewayMetadata) metaData.custom(SnapshottableGatewayMetadata.TYPE)).getData(), equalTo("before_snapshot_s_gw"));
|
||||
assertThat(((NonSnapshottableGatewayMetadata) metaData.custom(NonSnapshottableGatewayMetadata.TYPE)).getData(), equalTo("after_snapshot_ns_gw"));
|
||||
assertThat(((SnapshottableGatewayMetadata) metaData.custom(SnapshottableGatewayMetadata.TYPE)).getData(),
|
||||
equalTo("before_snapshot_s_gw"));
|
||||
assertThat(((NonSnapshottableGatewayMetadata) metaData.custom(NonSnapshottableGatewayMetadata.TYPE)).getData(),
|
||||
equalTo("after_snapshot_ns_gw"));
|
||||
|
||||
logger.info("--> restart all nodes");
|
||||
internalCluster().fullRestart();
|
||||
@ -299,13 +315,16 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
metaData = clusterState.getMetaData();
|
||||
assertThat(metaData.custom(SnapshottableMetadata.TYPE), nullValue());
|
||||
assertThat(metaData.custom(NonSnapshottableMetadata.TYPE), nullValue());
|
||||
assertThat(((SnapshottableGatewayMetadata) metaData.custom(SnapshottableGatewayMetadata.TYPE)).getData(), equalTo("before_snapshot_s_gw"));
|
||||
assertThat(((NonSnapshottableGatewayMetadata) metaData.custom(NonSnapshottableGatewayMetadata.TYPE)).getData(), equalTo("after_snapshot_ns_gw"));
|
||||
assertThat(((SnapshottableGatewayMetadata) metaData.custom(SnapshottableGatewayMetadata.TYPE)).getData(),
|
||||
equalTo("before_snapshot_s_gw"));
|
||||
assertThat(((NonSnapshottableGatewayMetadata) metaData.custom(NonSnapshottableGatewayMetadata.TYPE)).getData(),
|
||||
equalTo("after_snapshot_ns_gw"));
|
||||
// Shouldn't be returned as part of API response
|
||||
assertThat(metaData.custom(SnapshotableGatewayNoApiMetadata.TYPE), nullValue());
|
||||
// But should still be in state
|
||||
metaData = internalCluster().getInstance(ClusterService.class).state().metaData();
|
||||
assertThat(((SnapshotableGatewayNoApiMetadata) metaData.custom(SnapshotableGatewayNoApiMetadata.TYPE)).getData(), equalTo("before_snapshot_s_gw_noapi"));
|
||||
assertThat(((SnapshotableGatewayNoApiMetadata) metaData.custom(SnapshotableGatewayNoApiMetadata.TYPE)).getData(),
|
||||
equalTo("before_snapshot_s_gw_noapi"));
|
||||
}
|
||||
|
||||
private void updateClusterState(final ClusterStateUpdater updater) throws InterruptedException {
|
||||
@ -421,7 +440,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
|
||||
logger.info("--> execution was blocked on node [{}], aborting snapshot", blockedNode);
|
||||
|
||||
ActionFuture<AcknowledgedResponse> deleteSnapshotResponseFuture = internalCluster().client(nodes.get(0)).admin().cluster().prepareDeleteSnapshot("test-repo", "test-snap").execute();
|
||||
ActionFuture<AcknowledgedResponse> deleteSnapshotResponseFuture = internalCluster().client(nodes.get(0))
|
||||
.admin().cluster().prepareDeleteSnapshot("test-repo", "test-snap").execute();
|
||||
// Make sure that abort makes some progress
|
||||
Thread.sleep(100);
|
||||
unblockNode("test-repo", blockedNode);
|
||||
@ -437,7 +457,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
}
|
||||
|
||||
logger.info("--> making sure that snapshot no longer exists");
|
||||
assertThrows(client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").execute(), SnapshotMissingException.class);
|
||||
assertThrows(client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").execute(),
|
||||
SnapshotMissingException.class);
|
||||
// Subtract four files that will remain in the repository:
|
||||
// (1) index-1
|
||||
// (2) index-0 (because we keep the previous version) and
|
||||
@ -468,7 +489,9 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
|
||||
logger.info("--> shutdown one of the nodes");
|
||||
internalCluster().stopRandomDataNode();
|
||||
assertThat(client().admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).setTimeout("1m").setWaitForNodes("<2").execute().actionGet().isTimedOut(), equalTo(false));
|
||||
assertThat(client().admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).setTimeout("1m").setWaitForNodes("<2")
|
||||
.execute().actionGet().isTimedOut(),
|
||||
equalTo(false));
|
||||
|
||||
logger.info("--> create an index that will have all allocated shards");
|
||||
assertAcked(prepareCreate("test-idx-all", 1, Settings.builder().put("number_of_shards", 6)
|
||||
@ -518,17 +541,20 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
.setIndices("test-idx-all", "test-idx-none", "test-idx-some")
|
||||
.setWaitForCompletion(false).setPartial(true).execute().actionGet();
|
||||
assertBusy(() -> {
|
||||
SnapshotsStatusResponse snapshotsStatusResponse = client().admin().cluster().prepareSnapshotStatus("test-repo").setSnapshots("test-snap-2").get();
|
||||
SnapshotsStatusResponse snapshotsStatusResponse = client().admin().cluster().prepareSnapshotStatus("test-repo")
|
||||
.setSnapshots("test-snap-2").get();
|
||||
List<SnapshotStatus> snapshotStatuses = snapshotsStatusResponse.getSnapshots();
|
||||
assertEquals(snapshotStatuses.size(), 1);
|
||||
logger.trace("current snapshot status [{}]", snapshotStatuses.get(0));
|
||||
assertTrue(snapshotStatuses.get(0).getState().completed());
|
||||
}, 1, TimeUnit.MINUTES);
|
||||
SnapshotsStatusResponse snapshotsStatusResponse = client().admin().cluster().prepareSnapshotStatus("test-repo").setSnapshots("test-snap-2").get();
|
||||
SnapshotsStatusResponse snapshotsStatusResponse = client().admin().cluster().prepareSnapshotStatus("test-repo")
|
||||
.setSnapshots("test-snap-2").get();
|
||||
List<SnapshotStatus> snapshotStatuses = snapshotsStatusResponse.getSnapshots();
|
||||
assertThat(snapshotStatuses.size(), equalTo(1));
|
||||
SnapshotStatus snapshotStatus = snapshotStatuses.get(0);
|
||||
logger.info("State: [{}], Reason: [{}]", createSnapshotResponse.getSnapshotInfo().state(), createSnapshotResponse.getSnapshotInfo().reason());
|
||||
logger.info("State: [{}], Reason: [{}]",
|
||||
createSnapshotResponse.getSnapshotInfo().state(), createSnapshotResponse.getSnapshotInfo().reason());
|
||||
assertThat(snapshotStatus.getShardsStats().getTotalShards(), equalTo(18));
|
||||
assertThat(snapshotStatus.getShardsStats().getDoneShards(), lessThan(12));
|
||||
assertThat(snapshotStatus.getShardsStats().getDoneShards(), greaterThan(6));
|
||||
@ -536,7 +562,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
// There is slight delay between snapshot being marked as completed in the cluster state and on the file system
|
||||
// After it was marked as completed in the cluster state - we need to check if it's completed on the file system as well
|
||||
assertBusy(() -> {
|
||||
GetSnapshotsResponse response = client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-2").get();
|
||||
GetSnapshotsResponse response = client().admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setSnapshots("test-snap-2").get();
|
||||
assertThat(response.getSnapshots().size(), equalTo(1));
|
||||
SnapshotInfo snapshotInfo = response.getSnapshots().get(0);
|
||||
assertTrue(snapshotInfo.state().completed());
|
||||
@ -547,20 +574,26 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
createSnapshotResponse = client().admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-2")
|
||||
.setIndices("test-idx-all", "test-idx-none", "test-idx-some")
|
||||
.setWaitForCompletion(true).setPartial(true).execute().actionGet();
|
||||
logger.info("State: [{}], Reason: [{}]", createSnapshotResponse.getSnapshotInfo().state(), createSnapshotResponse.getSnapshotInfo().reason());
|
||||
logger.info("State: [{}], Reason: [{}]",
|
||||
createSnapshotResponse.getSnapshotInfo().state(), createSnapshotResponse.getSnapshotInfo().reason());
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(18));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), lessThan(12));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(6));
|
||||
assertThat(client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-2").execute().actionGet().getSnapshots().get(0).state(), equalTo(SnapshotState.PARTIAL));
|
||||
assertThat(client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-2").execute().actionGet()
|
||||
.getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.PARTIAL));
|
||||
}
|
||||
|
||||
assertAcked(client().admin().indices().prepareClose("test-idx-some", "test-idx-all").execute().actionGet());
|
||||
|
||||
logger.info("--> restore incomplete snapshot - should fail");
|
||||
assertThrows(client().admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-2").setRestoreGlobalState(false).setWaitForCompletion(true).execute(), SnapshotRestoreException.class);
|
||||
assertThrows(client().admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-2").setRestoreGlobalState(false)
|
||||
.setWaitForCompletion(true).execute(),
|
||||
SnapshotRestoreException.class);
|
||||
|
||||
logger.info("--> restore snapshot for the index that was snapshotted completely");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client().admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-2").setRestoreGlobalState(false).setIndices("test-idx-all").setWaitForCompletion(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client().admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-2")
|
||||
.setRestoreGlobalState(false).setIndices("test-idx-all").setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo(), notNullValue());
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), equalTo(6));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().successfulShards(), equalTo(6));
|
||||
@ -577,7 +610,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().successfulShards(), allOf(greaterThan(0), lessThan(6)));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().failedShards(), greaterThan(0));
|
||||
|
||||
assertThat(client().prepareSearch("test-idx-some").setSize(0).get().getHits().getTotalHits(), allOf(greaterThan(0L), lessThan(100L)));
|
||||
assertThat(client().prepareSearch("test-idx-some").setSize(0).get().getHits().getTotalHits(), allOf(greaterThan(0L),
|
||||
lessThan(100L)));
|
||||
|
||||
logger.info("--> restore snapshot for the index that didn't have any shards snapshotted successfully");
|
||||
cluster().wipeIndices("test-idx-none");
|
||||
@ -588,7 +622,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().successfulShards(), equalTo(0));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().failedShards(), equalTo(6));
|
||||
|
||||
assertThat(client().prepareSearch("test-idx-some").setSize(0).get().getHits().getTotalHits(), allOf(greaterThan(0L), lessThan(100L)));
|
||||
assertThat(client().prepareSearch("test-idx-some").setSize(0).get().getHits().getTotalHits(), allOf(greaterThan(0L),
|
||||
lessThan(100L)));
|
||||
}
|
||||
|
||||
public void testRestoreIndexWithShardsMissingInLocalGateway() throws Exception {
|
||||
@ -619,7 +654,9 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
assertThat(client().prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
logger.info("--> start snapshot");
|
||||
assertThat(client().admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1").setIndices("test-idx").setWaitForCompletion(true).get().getSnapshotInfo().state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(client().admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1").setIndices("test-idx")
|
||||
.setWaitForCompletion(true).get().getSnapshotInfo().state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
|
||||
logger.info("--> close the index");
|
||||
assertAcked(client().admin().indices().prepareClose("test-idx"));
|
||||
@ -632,16 +669,22 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
}
|
||||
});
|
||||
|
||||
assertThat(client().admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).setTimeout("1m").setWaitForNodes("2").execute().actionGet().isTimedOut(), equalTo(false));
|
||||
assertThat(client().admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).setTimeout("1m").setWaitForNodes("2")
|
||||
.execute().actionGet().isTimedOut(),
|
||||
equalTo(false));
|
||||
|
||||
logger.info("--> restore index snapshot");
|
||||
assertThat(client().admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-1").setRestoreGlobalState(false).setWaitForCompletion(true).get().getRestoreInfo().successfulShards(), equalTo(6));
|
||||
assertThat(client().admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-1").setRestoreGlobalState(false)
|
||||
.setWaitForCompletion(true).get().getRestoreInfo().successfulShards(),
|
||||
equalTo(6));
|
||||
|
||||
ensureGreen("test-idx");
|
||||
assertThat(client().prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
IntSet reusedShards = new IntHashSet();
|
||||
for (RecoveryState recoveryState : client().admin().indices().prepareRecoveries("test-idx").get().shardRecoveryStates().get("test-idx")) {
|
||||
List<RecoveryState> recoveryStates = client().admin().indices().prepareRecoveries("test-idx").get()
|
||||
.shardRecoveryStates().get("test-idx");
|
||||
for (RecoveryState recoveryState : recoveryStates) {
|
||||
if (recoveryState.getIndex().reusedBytes() > 0) {
|
||||
reusedShards.add(recoveryState.getShardId().getId());
|
||||
}
|
||||
@ -758,7 +801,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
final int numberOfShards = getNumShards("test-idx").numPrimaries;
|
||||
logger.info("number of shards: {}", numberOfShards);
|
||||
|
||||
dataNodeClient().admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(false).setIndices("test-idx").get();
|
||||
dataNodeClient().admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(false)
|
||||
.setIndices("test-idx").get();
|
||||
|
||||
logger.info("--> stopping master node");
|
||||
internalCluster().stopCurrentMasterNode();
|
||||
@ -766,14 +810,16 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
logger.info("--> wait until the snapshot is done");
|
||||
|
||||
assertBusy(() -> {
|
||||
GetSnapshotsResponse snapshotsStatusResponse = client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get();
|
||||
GetSnapshotsResponse snapshotsStatusResponse = client().admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setSnapshots("test-snap").get();
|
||||
SnapshotInfo snapshotInfo = snapshotsStatusResponse.getSnapshots().get(0);
|
||||
assertTrue(snapshotInfo.state().completed());
|
||||
}, 1, TimeUnit.MINUTES);
|
||||
|
||||
logger.info("--> verify that snapshot was succesful");
|
||||
|
||||
GetSnapshotsResponse snapshotsStatusResponse = client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get();
|
||||
GetSnapshotsResponse snapshotsStatusResponse = client().admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setSnapshots("test-snap").get();
|
||||
SnapshotInfo snapshotInfo = snapshotsStatusResponse.getSnapshots().get(0);
|
||||
assertEquals(SnapshotState.SUCCESS, snapshotInfo.state());
|
||||
assertEquals(snapshotInfo.totalShards(), snapshotInfo.successfulShards());
|
||||
@ -814,7 +860,8 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
final String masterNode = blockMasterFromFinalizingSnapshotOnSnapFile("test-repo");
|
||||
final String dataNode = blockNodeWithIndex("test-repo", "test-idx");
|
||||
|
||||
dataNodeClient().admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(false).setIndices("test-idx").get();
|
||||
dataNodeClient().admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(false)
|
||||
.setIndices("test-idx").get();
|
||||
|
||||
logger.info("--> stopping data node {}", dataNode);
|
||||
stopNode(dataNode);
|
||||
@ -824,14 +871,16 @@ public class DedicatedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTest
|
||||
logger.info("--> wait until the snapshot is done");
|
||||
|
||||
assertBusy(() -> {
|
||||
GetSnapshotsResponse snapshotsStatusResponse = client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get();
|
||||
GetSnapshotsResponse snapshotsStatusResponse = client().admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setSnapshots("test-snap").get();
|
||||
SnapshotInfo snapshotInfo = snapshotsStatusResponse.getSnapshots().get(0);
|
||||
assertTrue(snapshotInfo.state().completed());
|
||||
}, 1, TimeUnit.MINUTES);
|
||||
|
||||
logger.info("--> verify that snapshot was partial");
|
||||
|
||||
GetSnapshotsResponse snapshotsStatusResponse = client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get();
|
||||
GetSnapshotsResponse snapshotsStatusResponse = client().admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setSnapshots("test-snap").get();
|
||||
SnapshotInfo snapshotInfo = snapshotsStatusResponse.getSnapshots().get(0);
|
||||
assertEquals(SnapshotState.PARTIAL, snapshotInfo.state());
|
||||
assertNotEquals(snapshotInfo.totalShards(), snapshotInfo.successfulShards());
|
||||
|
||||
@ -138,7 +138,8 @@ public class RepositoriesIT extends AbstractSnapshotIntegTestCase {
|
||||
.get();
|
||||
fail("Shouldn't be here");
|
||||
} catch (RepositoryException ex) {
|
||||
assertThat(ex.toString(), containsString("location [" + location + "] doesn't match any of the locations specified by path.repo"));
|
||||
assertThat(ex.toString(), containsString("location [" + location + "] doesn't match any of the locations specified " +
|
||||
"by path.repo"));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -225,9 +225,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
}
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices(indicesToSnapshot).get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices(indicesToSnapshot).get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
List<SnapshotInfo> snapshotInfos = client.admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setSnapshots(randomFrom("test-snap", "_all", "*", "*-snap", "test*")).get().getSnapshots();
|
||||
@ -255,7 +257,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
client.admin().indices().prepareClose("test-idx-1", "test-idx-2").get();
|
||||
|
||||
logger.info("--> restore all indices from the snapshot");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
ensureGreen();
|
||||
@ -276,7 +279,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
logger.info("--> delete indices");
|
||||
cluster().wipeIndices("test-idx-1", "test-idx-2");
|
||||
logger.info("--> restore one index after deletion");
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx-*", "-test-idx-2").execute().actionGet();
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true)
|
||||
.setIndices("test-idx-*", "-test-idx-2").execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
ensureGreen();
|
||||
@ -327,7 +331,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
.setIndices(indexName)
|
||||
.get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().state(), equalTo(SnapshotState.SUCCESS));
|
||||
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot(repoName, snapshotName)
|
||||
@ -347,20 +352,24 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertAcked(client.admin().cluster().preparePutRepository("test-repo").setType("fs").setSettings(randomRepoSettings()));
|
||||
|
||||
createIndex("test");
|
||||
String originalIndexUUID = client().admin().indices().prepareGetSettings("test").get().getSetting("test", IndexMetaData.SETTING_INDEX_UUID);
|
||||
String originalIndexUUID = client().admin().indices().prepareGetSettings("test").get()
|
||||
.getSetting("test", IndexMetaData.SETTING_INDEX_UUID);
|
||||
assertTrue(originalIndexUUID, originalIndexUUID != null);
|
||||
assertFalse(originalIndexUUID, originalIndexUUID.equals(IndexMetaData.INDEX_UUID_NA_VALUE));
|
||||
ensureGreen();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
NumShards numShards = getNumShards("test");
|
||||
|
||||
cluster().wipeIndices("test");
|
||||
assertAcked(prepareCreate("test").setSettings(Settings.builder()
|
||||
.put(SETTING_NUMBER_OF_SHARDS, numShards.numPrimaries)));
|
||||
ensureGreen();
|
||||
String newIndexUUID = client().admin().indices().prepareGetSettings("test").get().getSetting("test", IndexMetaData.SETTING_INDEX_UUID);
|
||||
String newIndexUUID = client().admin().indices().prepareGetSettings("test").get()
|
||||
.getSetting("test", IndexMetaData.SETTING_INDEX_UUID);
|
||||
assertTrue(newIndexUUID, newIndexUUID != null);
|
||||
assertFalse(newIndexUUID, newIndexUUID.equals(IndexMetaData.INDEX_UUID_NA_VALUE));
|
||||
assertFalse(newIndexUUID, newIndexUUID.equals(originalIndexUUID));
|
||||
@ -368,20 +377,25 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
client.admin().indices().prepareClose("test").get();
|
||||
|
||||
logger.info("--> restore all indices from the snapshot");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
ensureGreen();
|
||||
String newAfterRestoreIndexUUID = client().admin().indices().prepareGetSettings("test").get().getSetting("test", IndexMetaData.SETTING_INDEX_UUID);
|
||||
assertTrue("UUID has changed after restore: " + newIndexUUID + " vs. " + newAfterRestoreIndexUUID, newIndexUUID.equals(newAfterRestoreIndexUUID));
|
||||
String newAfterRestoreIndexUUID = client().admin().indices().prepareGetSettings("test").get()
|
||||
.getSetting("test", IndexMetaData.SETTING_INDEX_UUID);
|
||||
assertTrue("UUID has changed after restore: " + newIndexUUID + " vs. " + newAfterRestoreIndexUUID,
|
||||
newIndexUUID.equals(newAfterRestoreIndexUUID));
|
||||
|
||||
logger.info("--> restore indices with different names");
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setRenamePattern("(.+)").setRenameReplacement("$1-copy").setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
String copyRestoreUUID = client().admin().indices().prepareGetSettings("test-copy").get().getSetting("test-copy", IndexMetaData.SETTING_INDEX_UUID);
|
||||
assertFalse("UUID has been reused on restore: " + copyRestoreUUID + " vs. " + originalIndexUUID, copyRestoreUUID.equals(originalIndexUUID));
|
||||
String copyRestoreUUID = client().admin().indices().prepareGetSettings("test-copy").get()
|
||||
.getSetting("test-copy", IndexMetaData.SETTING_INDEX_UUID);
|
||||
assertFalse("UUID has been reused on restore: " + copyRestoreUUID + " vs. " + originalIndexUUID,
|
||||
copyRestoreUUID.equals(originalIndexUUID));
|
||||
}
|
||||
|
||||
public void testRestoreWithDifferentMappingsAndSettings() throws Exception {
|
||||
@ -400,14 +414,17 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
ensureGreen();
|
||||
|
||||
logger.info("--> snapshot it");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> delete the index and recreate it with bar type");
|
||||
cluster().wipeIndices("test-idx");
|
||||
assertAcked(prepareCreate("test-idx", 2, Settings.builder()
|
||||
.put(SETTING_NUMBER_OF_SHARDS, numShards.numPrimaries).put(SETTING_NUMBER_OF_REPLICAS, between(0, 1)).put("refresh_interval", 5, TimeUnit.SECONDS)));
|
||||
.put(SETTING_NUMBER_OF_SHARDS, numShards.numPrimaries).put(SETTING_NUMBER_OF_REPLICAS, between(0, 1))
|
||||
.put("refresh_interval", 5, TimeUnit.SECONDS)));
|
||||
assertAcked(client().admin().indices().preparePutMapping("test-idx").setType("bar").setSource("baz", "type=text"));
|
||||
ensureGreen();
|
||||
|
||||
@ -415,11 +432,13 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
client.admin().indices().prepareClose("test-idx").get();
|
||||
|
||||
logger.info("--> restore all indices from the snapshot");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
logger.info("--> assert that old mapping is restored");
|
||||
ImmutableOpenMap<String, MappingMetaData> mappings = client().admin().cluster().prepareState().get().getState().getMetaData().getIndices().get("test-idx").getMappings();
|
||||
ImmutableOpenMap<String, MappingMetaData> mappings = client().admin().cluster().prepareState().get().getState().getMetaData()
|
||||
.getIndices().get("test-idx").getMappings();
|
||||
assertThat(mappings.get("foo"), notNullValue());
|
||||
assertThat(mappings.get("bar"), nullValue());
|
||||
|
||||
@ -437,11 +456,13 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(0));
|
||||
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
}
|
||||
|
||||
public void testRestoreAliases() throws Exception {
|
||||
@ -465,16 +486,20 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertAliasesExist(client.admin().indices().prepareAliasesExist("alias-123").get());
|
||||
|
||||
logger.info("--> snapshot");
|
||||
assertThat(client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setIndices().setWaitForCompletion(true).get().getSnapshotInfo().state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setIndices().setWaitForCompletion(true).get().getSnapshotInfo().state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
|
||||
logger.info("--> delete all indices");
|
||||
cluster().wipeIndices("test-idx-1", "test-idx-2", "test-idx-3");
|
||||
assertAliasesMissing(client.admin().indices().prepareAliasesExist("alias-123", "alias-1").get());
|
||||
|
||||
logger.info("--> restore snapshot with aliases");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
// We don't restore any indices here
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().successfulShards(), allOf(greaterThan(0), equalTo(restoreSnapshotResponse.getRestoreInfo().totalShards())));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().successfulShards(), allOf(greaterThan(0),
|
||||
equalTo(restoreSnapshotResponse.getRestoreInfo().totalShards())));
|
||||
|
||||
logger.info("--> check that aliases are restored");
|
||||
assertAliasesExist(client.admin().indices().prepareAliasesExist("alias-123", "alias-1").get());
|
||||
@ -489,9 +514,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertAliasesMissing(client.admin().indices().prepareAliasesExist("alias-123", "alias-1").get());
|
||||
|
||||
logger.info("--> restore snapshot without aliases");
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setRestoreGlobalState(true).setIncludeAliases(false).execute().actionGet();
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true)
|
||||
.setRestoreGlobalState(true).setIncludeAliases(false).execute().actionGet();
|
||||
// We don't restore any indices here
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().successfulShards(), allOf(greaterThan(0), equalTo(restoreSnapshotResponse.getRestoreInfo().totalShards())));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().successfulShards(), allOf(greaterThan(0),
|
||||
equalTo(restoreSnapshotResponse.getRestoreInfo().totalShards())));
|
||||
|
||||
logger.info("--> check that aliases are not restored and existing aliases still exist");
|
||||
assertAliasesMissing(client.admin().indices().prepareAliasesExist("alias-123", "alias-1").get());
|
||||
@ -528,10 +555,12 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
.get().isAcknowledged(), equalTo(true));
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setIndices().setWaitForCompletion(true).get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setIndices().setWaitForCompletion(true).get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(0));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
|
||||
logger.info("--> delete test template");
|
||||
assertThat(client.admin().indices().prepareDeleteTemplate("test-template").get().isAcknowledged(), equalTo(true));
|
||||
@ -539,7 +568,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertIndexTemplateMissing(getIndexTemplatesResponse, "test-template");
|
||||
|
||||
logger.info("--> restore cluster state");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
// We don't restore any indices here
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), equalTo(0));
|
||||
|
||||
@ -607,21 +637,30 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
}
|
||||
|
||||
logger.info("--> snapshot without global state");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-no-global-state").setIndices().setIncludeGlobalState(false).setWaitForCompletion(true).get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster()
|
||||
.prepareCreateSnapshot("test-repo", "test-snap-no-global-state").setIndices().setIncludeGlobalState(false)
|
||||
.setWaitForCompletion(true).get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(0));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-no-global-state").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
SnapshotsStatusResponse snapshotsStatusResponse = client.admin().cluster().prepareSnapshotStatus("test-repo").addSnapshots("test-snap-no-global-state").get();
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-no-global-state")
|
||||
.get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
SnapshotsStatusResponse snapshotsStatusResponse = client.admin().cluster().prepareSnapshotStatus("test-repo")
|
||||
.addSnapshots("test-snap-no-global-state").get();
|
||||
assertThat(snapshotsStatusResponse.getSnapshots().size(), equalTo(1));
|
||||
SnapshotStatus snapshotStatus = snapshotsStatusResponse.getSnapshots().get(0);
|
||||
assertThat(snapshotStatus.includeGlobalState(), equalTo(false));
|
||||
|
||||
logger.info("--> snapshot with global state");
|
||||
createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-with-global-state").setIndices().setIncludeGlobalState(true).setWaitForCompletion(true).get();
|
||||
createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-with-global-state")
|
||||
.setIndices().setIncludeGlobalState(true).setWaitForCompletion(true).get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(0));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-with-global-state").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
snapshotsStatusResponse = client.admin().cluster().prepareSnapshotStatus("test-repo").addSnapshots("test-snap-with-global-state").get();
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-with-global-state")
|
||||
.get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
snapshotsStatusResponse = client.admin().cluster().prepareSnapshotStatus("test-repo")
|
||||
.addSnapshots("test-snap-with-global-state").get();
|
||||
assertThat(snapshotsStatusResponse.getSnapshots().size(), equalTo(1));
|
||||
snapshotStatus = snapshotsStatusResponse.getSnapshots().get(0);
|
||||
assertThat(snapshotStatus.includeGlobalState(), equalTo(true));
|
||||
@ -644,7 +683,9 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
}
|
||||
|
||||
logger.info("--> try restoring cluster state from snapshot without global state");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-no-global-state").setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster()
|
||||
.prepareRestoreSnapshot("test-repo", "test-snap-no-global-state")
|
||||
.setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), equalTo(0));
|
||||
|
||||
logger.info("--> check that template wasn't restored");
|
||||
@ -652,7 +693,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertIndexTemplateMissing(getIndexTemplatesResponse, "test-template");
|
||||
|
||||
logger.info("--> restore cluster state");
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-with-global-state").setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-with-global-state")
|
||||
.setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), equalTo(0));
|
||||
|
||||
if (testTemplate) {
|
||||
@ -684,10 +726,14 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
logger.info("--> snapshot without global state but with indices");
|
||||
createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-no-global-state-with-index").setIndices("test-idx").setIncludeGlobalState(false).setWaitForCompletion(true).get();
|
||||
createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-no-global-state-with-index")
|
||||
.setIndices("test-idx").setIncludeGlobalState(false).setWaitForCompletion(true).get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-no-global-state-with-index").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap-no-global-state-with-index")
|
||||
.get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
|
||||
logger.info("--> delete global state and index ");
|
||||
cluster().wipeIndices("test-idx");
|
||||
@ -706,7 +752,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertIndexTemplateMissing(getIndexTemplatesResponse, "test-template");
|
||||
|
||||
logger.info("--> try restoring index and cluster state from snapshot without global state");
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-no-global-state-with-index").setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap-no-global-state-with-index")
|
||||
.setWaitForCompletion(true).setRestoreGlobalState(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().failedShards(), equalTo(0));
|
||||
|
||||
@ -743,7 +790,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> snapshot");
|
||||
try {
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
if (createSnapshotResponse.getSnapshotInfo().totalShards() == createSnapshotResponse.getSnapshotInfo().successfulShards()) {
|
||||
// If we are here, that means we didn't have any failures, let's check it
|
||||
assertThat(getFailureCount("test-repo"), equalTo(0L));
|
||||
@ -755,7 +803,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(shardFailure.nodeId(), notNullValue());
|
||||
assertThat(shardFailure.index(), equalTo("test-idx"));
|
||||
}
|
||||
GetSnapshotsResponse getSnapshotsResponse = client.admin().cluster().prepareGetSnapshots("test-repo").addSnapshots("test-snap").get();
|
||||
GetSnapshotsResponse getSnapshotsResponse = client.admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.addSnapshots("test-snap").get();
|
||||
assertThat(getSnapshotsResponse.getSnapshots().size(), equalTo(1));
|
||||
SnapshotInfo snapshotInfo = getSnapshotsResponse.getSnapshots().get(0);
|
||||
if (snapshotInfo.state() == SnapshotState.SUCCESS) {
|
||||
@ -791,7 +840,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
if (createSnapshotResponse.getSnapshotInfo().totalShards() == createSnapshotResponse.getSnapshotInfo().successfulShards()) {
|
||||
logger.info("--> no failures");
|
||||
// If we are here, that means we didn't have any failures, let's check it
|
||||
@ -804,7 +854,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(shardFailure.nodeId(), notNullValue());
|
||||
assertThat(shardFailure.index(), equalTo("test-idx"));
|
||||
}
|
||||
GetSnapshotsResponse getSnapshotsResponse = client.admin().cluster().prepareGetSnapshots("test-repo").addSnapshots("test-snap").get();
|
||||
GetSnapshotsResponse getSnapshotsResponse = client.admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.addSnapshots("test-snap").get();
|
||||
assertThat(getSnapshotsResponse.getSnapshots().size(), equalTo(1));
|
||||
SnapshotInfo snapshotInfo = getSnapshotsResponse.getSnapshots().get(0);
|
||||
assertThat(snapshotInfo.state(), equalTo(SnapshotState.PARTIAL));
|
||||
@ -812,7 +863,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(snapshotInfo.totalShards(), greaterThan(snapshotInfo.successfulShards()));
|
||||
|
||||
// Verify that snapshot status also contains the same failures
|
||||
SnapshotsStatusResponse snapshotsStatusResponse = client.admin().cluster().prepareSnapshotStatus("test-repo").addSnapshots("test-snap").get();
|
||||
SnapshotsStatusResponse snapshotsStatusResponse = client.admin().cluster().prepareSnapshotStatus("test-repo")
|
||||
.addSnapshots("test-snap").get();
|
||||
assertThat(snapshotsStatusResponse.getSnapshots().size(), equalTo(1));
|
||||
SnapshotStatus snapshotStatus = snapshotsStatusResponse.getSnapshots().get(0);
|
||||
assertThat(snapshotStatus.getIndices().size(), equalTo(1));
|
||||
@ -855,9 +907,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(createSnapshotResponse.getSnapshotInfo().successfulShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().successfulShards()));
|
||||
|
||||
logger.info("--> update repository with mock version");
|
||||
assertAcked(client.admin().cluster().preparePutRepository("test-repo")
|
||||
@ -1114,9 +1168,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(createSnapshotResponse.getSnapshotInfo().successfulShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().successfulShards()));
|
||||
|
||||
logger.info("--> update repository with mock version");
|
||||
assertAcked(client.admin().cluster().preparePutRepository("test-repo")
|
||||
@ -1144,14 +1200,16 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
// Now read restore results and make sure it failed
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = restoreSnapshotResponseFuture.actionGet(TimeValue.timeValueSeconds(10));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().failedShards(), greaterThan(0));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), equalTo(restoreSnapshotResponse.getRestoreInfo().failedShards()));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(),
|
||||
equalTo(restoreSnapshotResponse.getRestoreInfo().failedShards()));
|
||||
|
||||
logger.info("--> restoring working repository");
|
||||
assertAcked(client.admin().cluster().preparePutRepository("test-repo")
|
||||
.setType("fs").setSettings(Settings.builder().put("location", repositoryLocation)));
|
||||
|
||||
logger.info("--> trying to restore index again");
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().failedShards(), equalTo(0));
|
||||
SearchResponse countResponse = client.prepareSearch("test-idx").setSize(0).get();
|
||||
@ -1168,10 +1226,12 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
.put("location", randomRepoPath())));
|
||||
|
||||
logger.info("--> creating index that cannot be allocated");
|
||||
prepareCreate("test-idx", 2, Settings.builder().put(IndexMetaData.INDEX_ROUTING_INCLUDE_GROUP_SETTING.getKey() + "tag", "nowhere").put("index.number_of_shards", 3)).setWaitForActiveShards(ActiveShardCount.NONE).get();
|
||||
prepareCreate("test-idx", 2, Settings.builder().put(IndexMetaData.INDEX_ROUTING_INCLUDE_GROUP_SETTING.getKey() + "tag", "nowhere")
|
||||
.put("index.number_of_shards", 3)).setWaitForActiveShards(ActiveShardCount.NONE).get();
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().state(), equalTo(SnapshotState.FAILED));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(3));
|
||||
@ -1201,9 +1261,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
}
|
||||
refresh();
|
||||
logger.info("--> snapshot {}", i);
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-" + i).setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-" + i)
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
// Store number of files after each snapshot
|
||||
numberOfFiles[i] = numberOfFiles(repo);
|
||||
}
|
||||
@ -1224,7 +1286,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> restore index");
|
||||
String lastSnapshot = "test-snap-" + (numberOfSnapshots - 1);
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", lastSnapshot).setWaitForCompletion(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", lastSnapshot)
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(10L * numberOfSnapshots));
|
||||
@ -1305,9 +1368,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
client().prepareIndex("test-idx-2", "_doc").setSource("foo", "bar"));
|
||||
|
||||
logger.info("--> creating snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1").setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1")
|
||||
.setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> delete global state metadata");
|
||||
Path metadata = repo.resolve("meta-" + createSnapshotResponse.getSnapshotInfo().snapshotId().getUUID() + ".dat");
|
||||
@ -1338,9 +1403,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
client().prepareIndex("test-idx-2", "_doc").setSource("foo", "bar"));
|
||||
|
||||
logger.info("--> creating snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1").setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1")
|
||||
.setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> truncate snapshot file to make it unreadable");
|
||||
Path snapshotPath = repo.resolve("snap-" + createSnapshotResponse.getSnapshotInfo().snapshotId().getUUID() + ".dat");
|
||||
@ -1354,9 +1421,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThrows(client.admin().cluster().prepareGetSnapshots("test-repo").addSnapshots("test-snap-1"), SnapshotMissingException.class);
|
||||
|
||||
logger.info("--> make sure that we can create the snapshot again");
|
||||
createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1").setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1")
|
||||
.setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
}
|
||||
|
||||
/** Tests that a snapshot with a corrupted global state file can still be deleted */
|
||||
@ -1479,7 +1548,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(stateResponse.getState().routingTable().index("test-idx-closed"), nullValue());
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx*").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx*").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().indices().size(), equalTo(1));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().shardFailures().size(), equalTo(0));
|
||||
|
||||
@ -1487,7 +1557,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
client.admin().cluster().prepareDeleteSnapshot("test-repo", "test-snap").get();
|
||||
|
||||
logger.info("--> snapshot with closed index");
|
||||
assertBlocked(client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx", "test-idx-closed"), MetaDataIndexStateService.INDEX_CLOSED_BLOCK);
|
||||
assertBlocked(client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true)
|
||||
.setIndices("test-idx", "test-idx-closed"), MetaDataIndexStateService.INDEX_CLOSED_BLOCK);
|
||||
}
|
||||
|
||||
public void testSnapshotSingleClosedIndex() throws Exception {
|
||||
@ -1535,9 +1606,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(client.prepareSearch("test-idx-2").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx-1", "test-idx-2").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx-1", "test-idx-2").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> restore indices with different names");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
@ -1572,7 +1645,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> try renaming indices using the same name");
|
||||
try {
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setRenamePattern("(.+)").setRenameReplacement("same-name").setWaitForCompletion(true).execute().actionGet();
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setRenamePattern("(.+)")
|
||||
.setRenameReplacement("same-name").setWaitForCompletion(true).execute().actionGet();
|
||||
fail("Shouldn't be here");
|
||||
} catch (SnapshotRestoreException ex) {
|
||||
// Expected
|
||||
@ -1580,7 +1654,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> try renaming indices using the same name");
|
||||
try {
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setRenamePattern("test-idx-2").setRenameReplacement("test-idx-1").setWaitForCompletion(true).execute().actionGet();
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setRenamePattern("test-idx-2")
|
||||
.setRenameReplacement("test-idx-1").setWaitForCompletion(true).execute().actionGet();
|
||||
fail("Shouldn't be here");
|
||||
} catch (SnapshotRestoreException ex) {
|
||||
// Expected
|
||||
@ -1588,7 +1663,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> try renaming indices using invalid index name");
|
||||
try {
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setIndices("test-idx-1").setRenamePattern(".+").setRenameReplacement("__WRONG__").setWaitForCompletion(true).execute().actionGet();
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setIndices("test-idx-1").setRenamePattern(".+")
|
||||
.setRenameReplacement("__WRONG__").setWaitForCompletion(true).execute().actionGet();
|
||||
fail("Shouldn't be here");
|
||||
} catch (InvalidIndexNameException ex) {
|
||||
// Expected
|
||||
@ -1596,7 +1672,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> try renaming indices into existing alias name");
|
||||
try {
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setIndices("test-idx-1").setRenamePattern(".+").setRenameReplacement("alias-3").setWaitForCompletion(true).execute().actionGet();
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setIndices("test-idx-1").setRenamePattern(".+")
|
||||
.setRenameReplacement("alias-3").setWaitForCompletion(true).execute().actionGet();
|
||||
fail("Shouldn't be here");
|
||||
} catch (InvalidIndexNameException ex) {
|
||||
// Expected
|
||||
@ -1604,7 +1681,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> try renaming indices into existing alias of itself");
|
||||
try {
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setIndices("test-idx-1").setRenamePattern("test-idx").setRenameReplacement("alias").setWaitForCompletion(true).execute().actionGet();
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setIndices("test-idx-1").setRenamePattern("test-idx")
|
||||
.setRenameReplacement("alias").setWaitForCompletion(true).execute().actionGet();
|
||||
fail("Shouldn't be here");
|
||||
} catch (SnapshotRestoreException ex) {
|
||||
// Expected
|
||||
@ -1612,7 +1690,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> try renaming indices into existing alias of another restored index");
|
||||
try {
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setIndices("test-idx-1", "test-idx-2").setRenamePattern("test-idx-1").setRenameReplacement("alias-2").setWaitForCompletion(true).execute().actionGet();
|
||||
client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setIndices("test-idx-1", "test-idx-2")
|
||||
.setRenamePattern("test-idx-1").setRenameReplacement("alias-2").setWaitForCompletion(true).execute().actionGet();
|
||||
fail("Shouldn't be here");
|
||||
} catch (SnapshotRestoreException ex) {
|
||||
// Expected
|
||||
@ -1668,7 +1747,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
logger.info("Number of failed shards [{}]", snapshotInfo.shardFailures().size());
|
||||
logger.info("--> done");
|
||||
|
||||
List<SnapshotInfo> snapshotInfos = client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get().getSnapshots();
|
||||
List<SnapshotInfo> snapshotInfos = client().admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setSnapshots("test-snap").get().getSnapshots();
|
||||
|
||||
assertThat(snapshotInfos.size(), equalTo(1));
|
||||
assertThat(snapshotInfos.get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
@ -1682,7 +1762,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
.setType("fs").setSettings(Settings.builder().put("location", repositoryLocation)));
|
||||
|
||||
logger.info("--> restore index");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
@ -1751,7 +1832,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
logger.info("Number of failed shards [{}]", snapshotInfo.shardFailures().size());
|
||||
logger.info("--> done");
|
||||
|
||||
List<SnapshotInfo> snapshotInfos = client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get().getSnapshots();
|
||||
List<SnapshotInfo> snapshotInfos = client().admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setSnapshots("test-snap").get().getSnapshots();
|
||||
|
||||
assertThat(snapshotInfos.size(), equalTo(1));
|
||||
assertThat(snapshotInfos.get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
@ -1765,7 +1847,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
.setType("fs").setSettings(Settings.builder().put("location", repositoryLocation)));
|
||||
|
||||
logger.info("--> restore index");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
@ -1793,11 +1876,14 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
refresh();
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
|
||||
logger.info("--> delete index");
|
||||
cluster().wipeIndices("test-idx");
|
||||
@ -1810,7 +1896,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
.put("readonly", true)
|
||||
.put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES)));
|
||||
logger.info("--> restore index after deletion");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("readonly-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("readonly-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
@ -1821,10 +1908,14 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(getSnapshotsResponse.getSnapshots().size(), equalTo(1));
|
||||
|
||||
logger.info("--> try deleting snapshot");
|
||||
assertThrows(client.admin().cluster().prepareDeleteSnapshot("readonly-repo", "test-snap"), RepositoryException.class, "cannot delete snapshot from a readonly repository");
|
||||
assertThrows(client.admin().cluster().prepareDeleteSnapshot("readonly-repo", "test-snap"), RepositoryException.class,
|
||||
"cannot delete snapshot from a readonly repository");
|
||||
|
||||
logger.info("--> try making another snapshot");
|
||||
assertThrows(client.admin().cluster().prepareCreateSnapshot("readonly-repo", "test-snap-2").setWaitForCompletion(true).setIndices("test-idx"), RepositoryException.class, "cannot create snapshot in a readonly repository");
|
||||
assertThrows(client.admin().cluster().prepareCreateSnapshot("readonly-repo", "test-snap-2")
|
||||
.setWaitForCompletion(true).setIndices("test-idx"),
|
||||
RepositoryException.class,
|
||||
"cannot create snapshot in a readonly repository");
|
||||
}
|
||||
|
||||
public void testThrottling() throws Exception {
|
||||
@ -1853,15 +1944,18 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
logger.info("--> snapshot");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> delete index");
|
||||
cluster().wipeIndices("test-idx");
|
||||
|
||||
logger.info("--> restore index");
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
|
||||
RestoreSnapshotResponse restoreSnapshotResponse = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).execute().actionGet();
|
||||
assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
|
||||
assertThat(client.prepareSearch("test-idx").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
|
||||
|
||||
@ -1949,7 +2043,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
}
|
||||
|
||||
logger.info("--> checking that _current returns the currently running snapshot");
|
||||
GetSnapshotsResponse getResponse = client.admin().cluster().prepareGetSnapshots("test-repo").setCurrentSnapshot().execute().actionGet();
|
||||
GetSnapshotsResponse getResponse = client.admin().cluster().prepareGetSnapshots("test-repo")
|
||||
.setCurrentSnapshot().execute().actionGet();
|
||||
assertThat(getResponse.getSnapshots().size(), equalTo(1));
|
||||
SnapshotInfo snapshotInfo = getResponse.getSnapshots().get(0);
|
||||
assertThat(snapshotInfo.state(), equalTo(SnapshotState.IN_PROGRESS));
|
||||
@ -1980,7 +2075,9 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(response.getSnapshots().size(), equalTo(0));
|
||||
|
||||
logger.info("--> checking that _current no longer returns the snapshot");
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").addSnapshots("_current").execute().actionGet().getSnapshots().isEmpty(), equalTo(true));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").addSnapshots("_current")
|
||||
.execute().actionGet().getSnapshots().isEmpty(),
|
||||
equalTo(true));
|
||||
|
||||
// test that getting an unavailable snapshot status throws an exception if ignoreUnavailable is false on the request
|
||||
SnapshotMissingException ex = expectThrows(SnapshotMissingException.class, () ->
|
||||
@ -2064,24 +2161,32 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
flushAndRefresh();
|
||||
assertNoFailures(client().admin().indices().prepareForceMerge("test").setFlush(true).setMaxNumSegments(1).get());
|
||||
|
||||
CreateSnapshotResponse createSnapshotResponseFirst = client.admin().cluster().prepareCreateSnapshot("test-repo", "test").setWaitForCompletion(true).setIndices("test").get();
|
||||
CreateSnapshotResponse createSnapshotResponseFirst = client.admin().cluster().prepareCreateSnapshot("test-repo", "test")
|
||||
.setWaitForCompletion(true).setIndices("test").get();
|
||||
assertThat(createSnapshotResponseFirst.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponseFirst.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponseFirst.getSnapshotInfo().totalShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(createSnapshotResponseFirst.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponseFirst.getSnapshotInfo().totalShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test").get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
{
|
||||
SnapshotStatus snapshotStatus = client.admin().cluster().prepareSnapshotStatus("test-repo").setSnapshots("test").get().getSnapshots().get(0);
|
||||
SnapshotStatus snapshotStatus = client.admin().cluster().prepareSnapshotStatus("test-repo")
|
||||
.setSnapshots("test").get().getSnapshots().get(0);
|
||||
List<SnapshotIndexShardStatus> shards = snapshotStatus.getShards();
|
||||
for (SnapshotIndexShardStatus status : shards) {
|
||||
assertThat(status.getStats().getProcessedFileCount(), greaterThan(1));
|
||||
}
|
||||
}
|
||||
|
||||
CreateSnapshotResponse createSnapshotResponseSecond = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-1").setWaitForCompletion(true).setIndices("test").get();
|
||||
CreateSnapshotResponse createSnapshotResponseSecond = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-1")
|
||||
.setWaitForCompletion(true).setIndices("test").get();
|
||||
assertThat(createSnapshotResponseSecond.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponseSecond.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponseSecond.getSnapshotInfo().totalShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-1").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(createSnapshotResponseSecond.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponseSecond.getSnapshotInfo().totalShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-1").get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
{
|
||||
SnapshotStatus snapshotStatus = client.admin().cluster().prepareSnapshotStatus("test-repo").setSnapshots("test-1").get().getSnapshots().get(0);
|
||||
SnapshotStatus snapshotStatus = client.admin().cluster().prepareSnapshotStatus("test-repo")
|
||||
.setSnapshots("test-1").get().getSnapshots().get(0);
|
||||
List<SnapshotIndexShardStatus> shards = snapshotStatus.getShards();
|
||||
for (SnapshotIndexShardStatus status : shards) {
|
||||
assertThat(status.getStats().getProcessedFileCount(), equalTo(0));
|
||||
@ -2089,12 +2194,16 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
}
|
||||
|
||||
client().prepareDelete("test", "_doc", "1").get();
|
||||
CreateSnapshotResponse createSnapshotResponseThird = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-2").setWaitForCompletion(true).setIndices("test").get();
|
||||
CreateSnapshotResponse createSnapshotResponseThird = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-2")
|
||||
.setWaitForCompletion(true).setIndices("test").get();
|
||||
assertThat(createSnapshotResponseThird.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponseThird.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponseThird.getSnapshotInfo().totalShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-2").get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
|
||||
assertThat(createSnapshotResponseThird.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponseThird.getSnapshotInfo().totalShards()));
|
||||
assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-2").get().getSnapshots().get(0).state(),
|
||||
equalTo(SnapshotState.SUCCESS));
|
||||
{
|
||||
SnapshotStatus snapshotStatus = client.admin().cluster().prepareSnapshotStatus("test-repo").setSnapshots("test-2").get().getSnapshots().get(0);
|
||||
SnapshotStatus snapshotStatus = client.admin().cluster().prepareSnapshotStatus("test-repo")
|
||||
.setSnapshots("test-2").get().getSnapshots().get(0);
|
||||
List<SnapshotIndexShardStatus> shards = snapshotStatus.getShards();
|
||||
for (SnapshotIndexShardStatus status : shards) {
|
||||
// we flush before the snapshot such that we have to process the segments_N files plus the .del file
|
||||
@ -2130,7 +2239,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertAcked(prepareCreate("test-idx", 2, indexSettings));
|
||||
|
||||
int numberOfShards = getNumShards("test-idx").numPrimaries;
|
||||
assertAcked(client().admin().indices().preparePutMapping("test-idx").setType("type1").setSource("field1", "type=text,analyzer=standard,search_analyzer=my_analyzer"));
|
||||
assertAcked(client().admin().indices().preparePutMapping("test-idx").setType("type1")
|
||||
.setSource("field1", "type=text,analyzer=standard,search_analyzer=my_analyzer"));
|
||||
final int numdocs = randomIntBetween(10, 100);
|
||||
IndexRequestBuilder[] builders = new IndexRequestBuilder[numdocs];
|
||||
for (int i = 0; i < builders.length; i++) {
|
||||
@ -2144,9 +2254,11 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertHitCount(client.prepareSearch("test-idx").setSize(0).setQuery(matchQuery("field1", "bar")).get(), numdocs);
|
||||
|
||||
logger.info("--> snapshot it");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> delete the index and recreate it while changing refresh interval and analyzer");
|
||||
cluster().wipeIndices("test-idx");
|
||||
@ -2256,7 +2368,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
|
||||
.setWaitForCompletion(true).setIndices("test-idx").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> remove blocks and delete index");
|
||||
disableIndexBlock("test-idx", IndexMetaData.SETTING_BLOCKS_METADATA);
|
||||
@ -2404,7 +2517,8 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().state(), equalTo((SnapshotState.PARTIAL)));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().failedShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), lessThan(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
lessThan(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
} else {
|
||||
logger.info("Snapshot successfully completed");
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().state(), equalTo((SnapshotState.SUCCESS)));
|
||||
@ -2565,12 +2679,15 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
|
||||
logger.info("--> snapshot");
|
||||
final String snapshotName = "test-snap";
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot(repositoryName, snapshotName).setWaitForCompletion(true).setIndices(idxName).get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot(repositoryName, snapshotName)
|
||||
.setWaitForCompletion(true).setIndices(idxName).get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> emulate an orphan snapshot");
|
||||
RepositoriesService repositoriesService = internalCluster().getInstance(RepositoriesService.class, internalCluster().getMasterName());
|
||||
RepositoriesService repositoriesService = internalCluster().getInstance(RepositoriesService.class,
|
||||
internalCluster().getMasterName());
|
||||
final RepositoryData repositoryData = getRepositoryData(repositoriesService.repository(repositoryName));
|
||||
final IndexId indexId = repositoryData.resolveIndexId(idxName);
|
||||
|
||||
@ -2593,7 +2710,9 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
System.currentTimeMillis(),
|
||||
repositoryData.getGenId(),
|
||||
shards.build()));
|
||||
return ClusterState.builder(currentState).putCustom(SnapshotsInProgress.TYPE, new SnapshotsInProgress(Collections.unmodifiableList(entries))).build();
|
||||
return ClusterState.builder(currentState)
|
||||
.putCustom(SnapshotsInProgress.TYPE, new SnapshotsInProgress(Collections.unmodifiableList(entries)))
|
||||
.build();
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -2614,11 +2733,13 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
}
|
||||
|
||||
private boolean waitForIndex(final String index, TimeValue timeout) throws InterruptedException {
|
||||
return awaitBusy(() -> client().admin().indices().prepareExists(index).execute().actionGet().isExists(), timeout.millis(), TimeUnit.MILLISECONDS);
|
||||
return awaitBusy(() -> client().admin().indices().prepareExists(index).execute().actionGet().isExists(),
|
||||
timeout.millis(), TimeUnit.MILLISECONDS);
|
||||
}
|
||||
|
||||
private boolean waitForRelocationsToStart(final String index, TimeValue timeout) throws InterruptedException {
|
||||
return awaitBusy(() -> client().admin().cluster().prepareHealth(index).execute().actionGet().getRelocatingShards() > 0, timeout.millis(), TimeUnit.MILLISECONDS);
|
||||
return awaitBusy(() -> client().admin().cluster().prepareHealth(index).execute().actionGet().getRelocatingShards() > 0,
|
||||
timeout.millis(), TimeUnit.MILLISECONDS);
|
||||
}
|
||||
|
||||
public void testSnapshotName() throws Exception {
|
||||
@ -2658,13 +2779,17 @@ public class SharedClusterSnapshotRestoreIT extends AbstractSnapshotIntegTestCas
|
||||
client().prepareIndex("test-idx-3", "_doc").setSource("foo", "bar"));
|
||||
|
||||
logger.info("--> creating 2 snapshots");
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1").setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-1")
|
||||
.setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-2").setWaitForCompletion(true).setIndices("test-idx-*").get();
|
||||
createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap-2").setWaitForCompletion(true)
|
||||
.setIndices("test-idx-*").get();
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(),
|
||||
equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
|
||||
|
||||
logger.info("--> truncate snapshot file to make it unreadable");
|
||||
Path snapshotPath = repo.resolve("snap-" + createSnapshotResponse.getSnapshotInfo().snapshotId().getUUID() + ".dat");
|
||||
|
||||
@ -39,9 +39,11 @@ public class SnapshotUtilsTests extends ESTestCase {
|
||||
assertIndexNameFiltering(new String[]{"foo", "bar", "baz"}, new String[]{"-ba*"}, new String[]{"foo"});
|
||||
assertIndexNameFiltering(new String[]{"foo", "bar", "baz"}, new String[]{"+ba*"}, new String[]{"bar", "baz"});
|
||||
assertIndexNameFiltering(new String[]{"foo", "bar", "baz"}, new String[]{"+bar", "+foo"}, new String[]{"bar", "foo"});
|
||||
assertIndexNameFiltering(new String[]{"foo", "bar", "baz"}, new String[]{"zzz", "bar"}, IndicesOptions.lenientExpandOpen(), new String[]{"bar"});
|
||||
assertIndexNameFiltering(new String[]{"foo", "bar", "baz"}, new String[]{"zzz", "bar"}, IndicesOptions.lenientExpandOpen(),
|
||||
new String[]{"bar"});
|
||||
assertIndexNameFiltering(new String[]{"foo", "bar", "baz"}, new String[]{""}, IndicesOptions.lenientExpandOpen(), new String[]{});
|
||||
assertIndexNameFiltering(new String[]{"foo", "bar", "baz"}, new String[]{"foo", "", "ba*"}, IndicesOptions.lenientExpandOpen(), new String[]{"foo", "bar", "baz"});
|
||||
assertIndexNameFiltering(new String[]{"foo", "bar", "baz"}, new String[]{"foo", "", "ba*"}, IndicesOptions.lenientExpandOpen(),
|
||||
new String[]{"foo", "bar", "baz"});
|
||||
}
|
||||
|
||||
private void assertIndexNameFiltering(String[] indices, String[] filter, String[] expected) {
|
||||
|
||||
@ -192,7 +192,9 @@ public class RandomShapeGenerator extends RandomGeoGenerator {
|
||||
p = xRandomPointIn(r, within);
|
||||
coordinatesBuilder.coordinate(p.getX(), p.getY());
|
||||
}
|
||||
ShapeBuilder pcb = (st == ShapeType.MULTIPOINT) ? new MultiPointBuilder(coordinatesBuilder.build()) : new LineStringBuilder(coordinatesBuilder);
|
||||
ShapeBuilder pcb = (st == ShapeType.MULTIPOINT)
|
||||
? new MultiPointBuilder(coordinatesBuilder.build())
|
||||
: new LineStringBuilder(coordinatesBuilder);
|
||||
return pcb;
|
||||
case MULTILINESTRING:
|
||||
MultiLineStringBuilder mlsb = new MultiLineStringBuilder();
|
||||
|
||||
@ -183,7 +183,8 @@ public class ElasticsearchGeoAssertions {
|
||||
assertEquals((MultiLineString) s1, (MultiLineString) s2);
|
||||
|
||||
} else {
|
||||
throw new RuntimeException("equality of shape types not supported [" + s1.getClass().getName() + " and " + s2.getClass().getName() + "]");
|
||||
throw new RuntimeException("equality of shape types not supported [" + s1.getClass().getName() + " and " +
|
||||
s2.getClass().getName() + "]");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -366,7 +366,8 @@ public class UpdateIT extends ESIntegTestCase {
|
||||
// check updates without script
|
||||
// add new field
|
||||
client().prepareIndex("test", "type1", "1").setSource("field", 1).execute().actionGet();
|
||||
client().prepareUpdate(indexOrAlias(), "type1", "1").setDoc(XContentFactory.jsonBuilder().startObject().field("field2", 2).endObject()).execute().actionGet();
|
||||
client().prepareUpdate(indexOrAlias(), "type1", "1")
|
||||
.setDoc(XContentFactory.jsonBuilder().startObject().field("field2", 2).endObject()).execute().actionGet();
|
||||
for (int i = 0; i < 5; i++) {
|
||||
GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
|
||||
assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("1"));
|
||||
@ -374,7 +375,8 @@ public class UpdateIT extends ESIntegTestCase {
|
||||
}
|
||||
|
||||
// change existing field
|
||||
client().prepareUpdate(indexOrAlias(), "type1", "1").setDoc(XContentFactory.jsonBuilder().startObject().field("field", 3).endObject()).execute().actionGet();
|
||||
client().prepareUpdate(indexOrAlias(), "type1", "1")
|
||||
.setDoc(XContentFactory.jsonBuilder().startObject().field("field", 3).endObject()).execute().actionGet();
|
||||
for (int i = 0; i < 5; i++) {
|
||||
GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
|
||||
assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("3"));
|
||||
@ -392,7 +394,8 @@ public class UpdateIT extends ESIntegTestCase {
|
||||
testMap.put("map1", 8);
|
||||
|
||||
client().prepareIndex("test", "type1", "1").setSource("map", testMap).execute().actionGet();
|
||||
client().prepareUpdate(indexOrAlias(), "type1", "1").setDoc(XContentFactory.jsonBuilder().startObject().field("map", testMap3).endObject()).execute().actionGet();
|
||||
client().prepareUpdate(indexOrAlias(), "type1", "1")
|
||||
.setDoc(XContentFactory.jsonBuilder().startObject().field("map", testMap3).endObject()).execute().actionGet();
|
||||
for (int i = 0; i < 5; i++) {
|
||||
GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet();
|
||||
Map map1 = (Map) getResponse.getSourceAsMap().get("map");
|
||||
@ -519,10 +522,12 @@ public class UpdateIT extends ESIntegTestCase {
|
||||
startLatch.await();
|
||||
for (int i = 0; i < numberOfUpdatesPerThread; i++) {
|
||||
if (i % 100 == 0) {
|
||||
logger.debug("Client [{}] issued [{}] of [{}] requests", Thread.currentThread().getName(), i, numberOfUpdatesPerThread);
|
||||
logger.debug("Client [{}] issued [{}] of [{}] requests",
|
||||
Thread.currentThread().getName(), i, numberOfUpdatesPerThread);
|
||||
}
|
||||
if (useBulkApi) {
|
||||
UpdateRequestBuilder updateRequestBuilder = client().prepareUpdate(indexOrAlias(), "type1", Integer.toString(i))
|
||||
UpdateRequestBuilder updateRequestBuilder = client()
|
||||
.prepareUpdate(indexOrAlias(), "type1", Integer.toString(i))
|
||||
.setScript(fieldIncScript)
|
||||
.setRetryOnConflict(Integer.MAX_VALUE)
|
||||
.setUpsert(jsonBuilder().startObject().field("field", 1).endObject());
|
||||
@ -538,7 +543,8 @@ public class UpdateIT extends ESIntegTestCase {
|
||||
logger.info("Client [{}] issued all [{}] requests.", Thread.currentThread().getName(), numberOfUpdatesPerThread);
|
||||
} catch (InterruptedException e) {
|
||||
// test infrastructure kills long-running tests by interrupting them, thus we handle this case separately
|
||||
logger.warn("Test was forcefully stopped. Client [{}] may still have outstanding requests.", Thread.currentThread().getName());
|
||||
logger.warn("Test was forcefully stopped. Client [{}] may still have outstanding requests.",
|
||||
Thread.currentThread().getName());
|
||||
failures.add(e);
|
||||
Thread.currentThread().interrupt();
|
||||
} catch (Exception e) {
|
||||
@ -709,7 +715,8 @@ public class UpdateIT extends ESIntegTestCase {
|
||||
long start = System.currentTimeMillis();
|
||||
do {
|
||||
long msRemaining = timeOut.getMillis() - (System.currentTimeMillis() - start);
|
||||
logger.info("[{}] going to try and acquire [{}] in [{}]ms [{}] available to acquire right now",name, maxRequests,msRemaining, requestsOutstanding.availablePermits());
|
||||
logger.info("[{}] going to try and acquire [{}] in [{}]ms [{}] available to acquire right now",
|
||||
name, maxRequests,msRemaining, requestsOutstanding.availablePermits());
|
||||
try {
|
||||
requestsOutstanding.tryAcquire(maxRequests, msRemaining, TimeUnit.MILLISECONDS );
|
||||
return;
|
||||
@ -717,7 +724,8 @@ public class UpdateIT extends ESIntegTestCase {
|
||||
//Just keep swimming
|
||||
}
|
||||
} while ((System.currentTimeMillis() - start) < timeOut.getMillis());
|
||||
throw new ElasticsearchTimeoutException("Requests were still outstanding after the timeout [" + timeOut + "] for type [" + name + "]" );
|
||||
throw new ElasticsearchTimeoutException("Requests were still outstanding after the timeout [" + timeOut + "] for type [" +
|
||||
name + "]" );
|
||||
}
|
||||
}
|
||||
final List<UpdateThread> threads = new ArrayList<>();
|
||||
@ -768,7 +776,8 @@ public class UpdateIT extends ESIntegTestCase {
|
||||
}
|
||||
}
|
||||
expectedVersion -= totalFailures;
|
||||
logger.error("Actual version [{}] Expected version [{}] Total failures [{}]", response.getVersion(), expectedVersion, totalFailures);
|
||||
logger.error("Actual version [{}] Expected version [{}] Total failures [{}]",
|
||||
response.getVersion(), expectedVersion, totalFailures);
|
||||
assertThat(response.getVersion(), equalTo((long) expectedVersion));
|
||||
assertThat(response.getVersion() + totalFailures,
|
||||
equalTo(
|
||||
|
||||
@ -69,16 +69,23 @@ public class SimpleValidateQueryIT extends ESIntegTestCase {
|
||||
|
||||
refresh();
|
||||
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.wrapperQuery("foo".getBytes(StandardCharsets.UTF_8))).execute().actionGet().isValid(), equalTo(false));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.queryStringQuery("_id:1")).execute().actionGet().isValid(), equalTo(true));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.queryStringQuery("_i:d:1")).execute().actionGet().isValid(), equalTo(false));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test")
|
||||
.setQuery(QueryBuilders.wrapperQuery("foo".getBytes(StandardCharsets.UTF_8))).execute().actionGet().isValid(), equalTo(false));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test")
|
||||
.setQuery(QueryBuilders.queryStringQuery("_id:1")).execute().actionGet().isValid(), equalTo(true));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test")
|
||||
.setQuery(QueryBuilders.queryStringQuery("_i:d:1")).execute().actionGet().isValid(), equalTo(false));
|
||||
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.queryStringQuery("foo:1")).execute().actionGet().isValid(), equalTo(true));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.queryStringQuery("bar:hey").lenient(false)).execute().actionGet().isValid(), equalTo(false));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test")
|
||||
.setQuery(QueryBuilders.queryStringQuery("foo:1")).execute().actionGet().isValid(), equalTo(true));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test")
|
||||
.setQuery(QueryBuilders.queryStringQuery("bar:hey").lenient(false)).execute().actionGet().isValid(), equalTo(false));
|
||||
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.queryStringQuery("nonexistent:hello")).execute().actionGet().isValid(), equalTo(true));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test")
|
||||
.setQuery(QueryBuilders.queryStringQuery("nonexistent:hello")).execute().actionGet().isValid(), equalTo(true));
|
||||
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.queryStringQuery("foo:1 AND")).execute().actionGet().isValid(), equalTo(false));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test")
|
||||
.setQuery(QueryBuilders.queryStringQuery("foo:1 AND")).execute().actionGet().isValid(), equalTo(false));
|
||||
}
|
||||
|
||||
public void testExplainValidateQueryTwoNodes() throws IOException {
|
||||
@ -89,8 +96,8 @@ public class SimpleValidateQueryIT extends ESIntegTestCase {
|
||||
.startObject("foo").field("type", "text").endObject()
|
||||
.startObject("bar").field("type", "integer").endObject()
|
||||
.startObject("baz").field("type", "text").field("analyzer", "standard").endObject()
|
||||
.startObject("pin").startObject("properties").startObject("location").field("type", "geo_point").endObject().endObject().endObject()
|
||||
.endObject().endObject().endObject())
|
||||
.startObject("pin").startObject("properties").startObject("location").field("type", "geo_point")
|
||||
.endObject().endObject().endObject().endObject().endObject().endObject())
|
||||
.execute().actionGet();
|
||||
|
||||
refresh();
|
||||
@ -114,7 +121,9 @@ public class SimpleValidateQueryIT extends ESIntegTestCase {
|
||||
.execute().actionGet();
|
||||
assertThat(response.isValid(), equalTo(true));
|
||||
assertThat(response.getQueryExplanation().size(), equalTo(1));
|
||||
assertThat(response.getQueryExplanation().get(0).getExplanation(), equalTo("(MatchNoDocsQuery(\"failed [bar] query, caused by number_format_exception:[For input string: \"foo\"]\") | foo:foo | baz:foo)"));
|
||||
assertThat(response.getQueryExplanation().get(0).getExplanation(),
|
||||
equalTo("(MatchNoDocsQuery(\"failed [bar] query, caused by number_format_exception:[For input string: \"foo\"]\") " +
|
||||
"| foo:foo | baz:foo)"));
|
||||
assertThat(response.getQueryExplanation().get(0).getError(), nullValue());
|
||||
}
|
||||
}
|
||||
@ -257,7 +266,8 @@ public class SimpleValidateQueryIT extends ESIntegTestCase {
|
||||
ensureGreen();
|
||||
refresh();
|
||||
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.wrapperQuery(new BytesArray("{\"foo\": \"bar\", \"query\": {\"term\" : { \"user\" : \"kimchy\" }}}"))).get().isValid(), equalTo(false));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.wrapperQuery(
|
||||
new BytesArray("{\"foo\": \"bar\", \"query\": {\"term\" : { \"user\" : \"kimchy\" }}}"))).get().isValid(), equalTo(false));
|
||||
}
|
||||
|
||||
public void testIrrelevantPropertiesAfterQuery() throws IOException {
|
||||
@ -265,7 +275,8 @@ public class SimpleValidateQueryIT extends ESIntegTestCase {
|
||||
ensureGreen();
|
||||
refresh();
|
||||
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.wrapperQuery(new BytesArray("{\"query\": {\"term\" : { \"user\" : \"kimchy\" }}, \"foo\": \"bar\"}"))).get().isValid(), equalTo(false));
|
||||
assertThat(client().admin().indices().prepareValidateQuery("test").setQuery(QueryBuilders.wrapperQuery(
|
||||
new BytesArray("{\"query\": {\"term\" : { \"user\" : \"kimchy\" }}, \"foo\": \"bar\"}"))).get().isValid(), equalTo(false));
|
||||
}
|
||||
|
||||
private static void assertExplanation(QueryBuilder queryBuilder, Matcher<String> matcher, boolean withRewrite) {
|
||||
|
||||
@ -54,14 +54,17 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
createIndex("test");
|
||||
ensureGreen();
|
||||
|
||||
// Note - external version doesn't throw version conflicts on deletes of non existent records. This is different from internal versioning
|
||||
// Note - external version doesn't throw version conflicts on deletes of non existent records.
|
||||
// This is different from internal versioning
|
||||
|
||||
DeleteResponse deleteResponse = client().prepareDelete("test", "type", "1").setVersion(17).setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
DeleteResponse deleteResponse = client().prepareDelete("test", "type", "1").setVersion(17).setVersionType(VersionType.EXTERNAL)
|
||||
.execute().actionGet();
|
||||
assertEquals(DocWriteResponse.Result.NOT_FOUND, deleteResponse.getResult());
|
||||
|
||||
// this should conflict with the delete command transaction which told us that the object was deleted at version 17.
|
||||
assertThrows(
|
||||
client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(13).setVersionType(VersionType.EXTERNAL).execute(),
|
||||
client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(13)
|
||||
.setVersionType(VersionType.EXTERNAL).execute(),
|
||||
VersionConflictEngineException.class
|
||||
);
|
||||
|
||||
@ -73,16 +76,20 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
public void testExternalGTE() throws Exception {
|
||||
createIndex("test");
|
||||
|
||||
IndexResponse indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(12).setVersionType(VersionType.EXTERNAL_GTE).get();
|
||||
IndexResponse indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(12)
|
||||
.setVersionType(VersionType.EXTERNAL_GTE).get();
|
||||
assertThat(indexResponse.getVersion(), equalTo(12L));
|
||||
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_2").setVersion(12).setVersionType(VersionType.EXTERNAL_GTE).get();
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_2").setVersion(12)
|
||||
.setVersionType(VersionType.EXTERNAL_GTE).get();
|
||||
assertThat(indexResponse.getVersion(), equalTo(12L));
|
||||
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_2").setVersion(14).setVersionType(VersionType.EXTERNAL_GTE).get();
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_2").setVersion(14)
|
||||
.setVersionType(VersionType.EXTERNAL_GTE).get();
|
||||
assertThat(indexResponse.getVersion(), equalTo(14L));
|
||||
|
||||
assertThrows(client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(13).setVersionType(VersionType.EXTERNAL_GTE),
|
||||
assertThrows(client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(13)
|
||||
.setVersionType(VersionType.EXTERNAL_GTE),
|
||||
VersionConflictEngineException.class);
|
||||
|
||||
client().admin().indices().prepareRefresh().execute().actionGet();
|
||||
@ -100,7 +107,8 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
|
||||
// Delete with a higher or equal version deletes all versions up to the given one.
|
||||
long v = randomIntBetween(14, 17);
|
||||
DeleteResponse deleteResponse = client().prepareDelete("test", "type", "1").setVersion(v).setVersionType(VersionType.EXTERNAL_GTE).execute().actionGet();
|
||||
DeleteResponse deleteResponse = client().prepareDelete("test", "type", "1").setVersion(v)
|
||||
.setVersionType(VersionType.EXTERNAL_GTE).execute().actionGet();
|
||||
assertEquals(DocWriteResponse.Result.DELETED, deleteResponse.getResult());
|
||||
assertThat(deleteResponse.getVersion(), equalTo(v));
|
||||
|
||||
@ -111,7 +119,8 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
|
||||
|
||||
// But delete with a higher version is OK.
|
||||
deleteResponse = client().prepareDelete("test", "type", "1").setVersion(18).setVersionType(VersionType.EXTERNAL_GTE).execute().actionGet();
|
||||
deleteResponse = client().prepareDelete("test", "type", "1").setVersion(18).setVersionType(VersionType.EXTERNAL_GTE)
|
||||
.execute().actionGet();
|
||||
assertEquals(DocWriteResponse.Result.NOT_FOUND, deleteResponse.getResult());
|
||||
assertThat(deleteResponse.getVersion(), equalTo(18L));
|
||||
}
|
||||
@ -120,13 +129,16 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
createIndex("test");
|
||||
ensureGreen();
|
||||
|
||||
IndexResponse indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(12).setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
IndexResponse indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(12)
|
||||
.setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
assertThat(indexResponse.getVersion(), equalTo(12L));
|
||||
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(14).setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(14)
|
||||
.setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
assertThat(indexResponse.getVersion(), equalTo(14L));
|
||||
|
||||
assertThrows(client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(13).setVersionType(VersionType.EXTERNAL).execute(),
|
||||
assertThrows(client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(13)
|
||||
.setVersionType(VersionType.EXTERNAL).execute(),
|
||||
VersionConflictEngineException.class);
|
||||
|
||||
if (randomBoolean()) {
|
||||
@ -142,7 +154,8 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
VersionConflictEngineException.class);
|
||||
|
||||
// Delete with a higher version deletes all versions up to the given one.
|
||||
DeleteResponse deleteResponse = client().prepareDelete("test", "type", "1").setVersion(17).setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
DeleteResponse deleteResponse = client().prepareDelete("test", "type", "1").setVersion(17)
|
||||
.setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
assertEquals(DocWriteResponse.Result.DELETED, deleteResponse.getResult());
|
||||
assertThat(deleteResponse.getVersion(), equalTo(17L));
|
||||
|
||||
@ -153,17 +166,21 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
|
||||
|
||||
// But delete with a higher version is OK.
|
||||
deleteResponse = client().prepareDelete("test", "type", "1").setVersion(18).setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
deleteResponse = client().prepareDelete("test", "type", "1").setVersion(18)
|
||||
.setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
assertEquals(DocWriteResponse.Result.NOT_FOUND, deleteResponse.getResult());
|
||||
assertThat(deleteResponse.getVersion(), equalTo(18L));
|
||||
|
||||
|
||||
// TODO: This behavior breaks rest api returning http status 201, good news is that it this is only the case until deletes GC kicks in.
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(19).setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
// TODO: This behavior breaks rest api returning http status 201
|
||||
// good news is that it this is only the case until deletes GC kicks in.
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(19).
|
||||
setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
assertThat(indexResponse.getVersion(), equalTo(19L));
|
||||
|
||||
|
||||
deleteResponse = client().prepareDelete("test", "type", "1").setVersion(20).setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
deleteResponse = client().prepareDelete("test", "type", "1").setVersion(20).setVersionType(VersionType.EXTERNAL)
|
||||
.execute().actionGet();
|
||||
assertEquals(DocWriteResponse.Result.DELETED, deleteResponse.getResult());
|
||||
assertThat(deleteResponse.getVersion(), equalTo(20L));
|
||||
|
||||
@ -175,7 +192,8 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
Thread.sleep(300); // gc works based on estimated sampled time. Give it a chance...
|
||||
|
||||
// And now we have previous version return -1
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(20).setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
indexResponse = client().prepareIndex("test", "type", "1").setSource("field1", "value1_1").setVersion(20)
|
||||
.setVersionType(VersionType.EXTERNAL).execute().actionGet();
|
||||
assertThat(indexResponse.getVersion(), equalTo(20L));
|
||||
}
|
||||
|
||||
@ -189,7 +207,8 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
fail("did not hit expected exception");
|
||||
} catch (IllegalArgumentException iae) {
|
||||
// expected
|
||||
assertTrue(iae.getMessage().contains("failed to parse setting [index.gc_deletes] with value [42] as a time value: unit is missing or unrecognized"));
|
||||
assertTrue(iae.getMessage().contains("failed to parse setting [index.gc_deletes] with value [42] as a time value: unit is " +
|
||||
"missing or unrecognized"));
|
||||
}
|
||||
}
|
||||
|
||||
@ -304,7 +323,8 @@ public class SimpleVersioningIT extends ESIntegTestCase {
|
||||
createIndex("test");
|
||||
ensureGreen();
|
||||
|
||||
BulkResponse bulkResponse = client().prepareBulk().add(client().prepareIndex("test", "type", "1").setSource("field1", "value1_1")).execute().actionGet();
|
||||
BulkResponse bulkResponse = client().prepareBulk().add(client().prepareIndex("test", "type", "1").setSource("field1", "value1_1"))
|
||||
.execute().actionGet();
|
||||
assertThat(bulkResponse.hasFailures(), equalTo(false));
|
||||
assertThat(bulkResponse.getItems().length, equalTo(1));
|
||||
IndexResponse indexResponse = bulkResponse.getItems()[0].getResponse();
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user