honeymoose/OpenSearch
1
0
Fork 0
mirror of https://github.com/honeymoose/OpenSearch.git synced 2025-02-17 10:25:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

cleanup MetaData#Builder construction

Browse Source 
have a better method name, and only allow to create a copy of the builder based on existing meta data when constructing the builder
This commit is contained in:
Shay Banon 2013-11-02 01:04:33 +01:00
parent acc5f584d4
commit d111e169a4
50 changed files with 341 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/org/elasticsearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java
View File

@ -225,7 +225,7 @@ public class TransportClusterUpdateSettingsAction extends TransportMasterNodeOpe
return currentState; return currentState;
} }
MetaData.Builder metaData = MetaData.builder().metaData(currentState.metaData()) MetaData.Builder metaData = MetaData.builder(currentState.metaData())
.persistentSettings(persistentSettings.build()) .persistentSettings(persistentSettings.build())
.transientSettings(transientSettings.build()); .transientSettings(transientSettings.build());

7
src/main/java/org/elasticsearch/action/admin/cluster/state/TransportClusterStateAction.java
View File

@ -34,7 +34,6 @@ import org.elasticsearch.threadpool.ThreadPool;
import org.elasticsearch.transport.TransportService; import org.elasticsearch.transport.TransportService;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
/** /**
* *
@ -93,9 +92,11 @@ public class TransportClusterStateAction extends TransportMasterNodeOperationAct
builder.blocks(currentState.blocks()); builder.blocks(currentState.blocks());
} }
if (!request.filterMetaData()) { if (!request.filterMetaData()) {
MetaData.Builder mdBuilder = newMetaDataBuilder(); MetaData.Builder mdBuilder;
if (request.filteredIndices().length == 0 && request.filteredIndexTemplates().length == 0) { if (request.filteredIndices().length == 0 && request.filteredIndexTemplates().length == 0) {
mdBuilder.metaData(currentState.metaData()); mdBuilder = MetaData.builder(currentState.metaData());
} else {
mdBuilder = MetaData.builder();
} }
if (request.filteredIndices().length > 0) { if (request.filteredIndices().length > 0) {

2
src/main/java/org/elasticsearch/action/admin/indices/warmer/delete/TransportDeleteWarmerAction.java
View File

@ -125,7 +125,7 @@ public class TransportDeleteWarmerAction extends TransportMasterNodeOperationAct
@Override @Override
public ClusterState execute(ClusterState currentState) { public ClusterState execute(ClusterState currentState) {
MetaData.Builder mdBuilder = MetaData.builder().metaData(currentState.metaData()); MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
boolean globalFoundAtLeastOne = false; boolean globalFoundAtLeastOne = false;
for (String index : request.indices()) { for (String index : request.indices()) {

2
src/main/java/org/elasticsearch/action/admin/indices/warmer/put/TransportPutWarmerAction.java
View File

@ -144,7 +144,7 @@ public class TransportPutWarmerAction extends TransportMasterNodeOperationAction
} }
// now replace it on the metadata // now replace it on the metadata
MetaData.Builder mdBuilder = MetaData.builder().metaData(currentState.metaData()); MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
for (String index : concreteIndices) { for (String index : concreteIndices) {
IndexMetaData indexMetaData = metaData.index(index); IndexMetaData indexMetaData = metaData.index(index);

16
src/main/java/org/elasticsearch/cluster/metadata/MetaData.java
View File

@ -99,7 +99,7 @@ public class MetaData implements Iterable<IndexMetaData> {
public static final ClusterBlock CLUSTER_READ_ONLY_BLOCK = new ClusterBlock(6, "cluster read-only (api)", false, false, RestStatus.FORBIDDEN, ClusterBlockLevel.WRITE, ClusterBlockLevel.METADATA); public static final ClusterBlock CLUSTER_READ_ONLY_BLOCK = new ClusterBlock(6, "cluster read-only (api)", false, false, RestStatus.FORBIDDEN, ClusterBlockLevel.WRITE, ClusterBlockLevel.METADATA);
public static final MetaData EMPTY_META_DATA = newMetaDataBuilder().build(); public static final MetaData EMPTY_META_DATA = builder().build();
private final long version; private final long version;
@ -920,9 +920,8 @@ public class MetaData implements Iterable<IndexMetaData> {
return new Builder(); return new Builder();
} }
public static Builder builder(MetaData metaData) {
public static Builder newMetaDataBuilder() { return new Builder(metaData);
return new Builder();
} }
public static class Builder { public static class Builder {
@ -933,19 +932,20 @@ public class MetaData implements Iterable<IndexMetaData> {
private Settings persistentSettings = ImmutableSettings.Builder.EMPTY_SETTINGS; private Settings persistentSettings = ImmutableSettings.Builder.EMPTY_SETTINGS;
private MapBuilder<String, IndexMetaData> indices = newMapBuilder(); private MapBuilder<String, IndexMetaData> indices = newMapBuilder();
private MapBuilder<String, IndexTemplateMetaData> templates = newMapBuilder(); private MapBuilder<String, IndexTemplateMetaData> templates = newMapBuilder();
private MapBuilder<String, Custom> customs = newMapBuilder(); private MapBuilder<String, Custom> customs = newMapBuilder();
public Builder metaData(MetaData metaData) { public Builder() {
}
public Builder(MetaData metaData) {
this.transientSettings = metaData.transientSettings; this.transientSettings = metaData.transientSettings;
this.persistentSettings = metaData.persistentSettings; this.persistentSettings = metaData.persistentSettings;
this.version = metaData.version; this.version = metaData.version;
this.indices.putAll(metaData.indices); this.indices.putAll(metaData.indices);
this.templates.putAll(metaData.templates); this.templates.putAll(metaData.templates);
this.customs.putAll(metaData.customs); this.customs.putAll(metaData.customs);
return this;
} }
public Builder put(IndexMetaData.Builder indexMetaDataBuilder) { public Builder put(IndexMetaData.Builder indexMetaDataBuilder) {

4
src/main/java/org/elasticsearch/cluster/metadata/MetaDataCreateIndexService.java
View File

@ -76,7 +76,6 @@ import java.util.concurrent.atomic.AtomicInteger;
import static com.google.common.collect.Maps.newHashMap; import static com.google.common.collect.Maps.newHashMap;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.*; import static org.elasticsearch.cluster.metadata.IndexMetaData.*;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
/** /**
@ -311,8 +310,7 @@ public class MetaDataCreateIndexService extends AbstractComponent {
throw e; throw e;
} }
MetaData newMetaData = newMetaDataBuilder() MetaData newMetaData = MetaData.builder(currentState.metaData())
.metaData(currentState.metaData())
.put(indexMetaData, false) .put(indexMetaData, false)
.build(); .build();

4
src/main/java/org/elasticsearch/cluster/metadata/MetaDataDeleteIndexService.java
View File

@ -44,7 +44,6 @@ import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
/** /**
* *
@ -126,8 +125,7 @@ public class MetaDataDeleteIndexService extends AbstractComponent {
RoutingTable.Builder routingTableBuilder = RoutingTable.builder().routingTable(currentState.routingTable()); RoutingTable.Builder routingTableBuilder = RoutingTable.builder().routingTable(currentState.routingTable());
routingTableBuilder.remove(request.index); routingTableBuilder.remove(request.index);
MetaData newMetaData = newMetaDataBuilder() MetaData newMetaData = MetaData.builder(currentState.metaData())
.metaData(currentState.metaData())
.remove(request.index) .remove(request.index)
.build(); .build();

3
src/main/java/org/elasticsearch/cluster/metadata/MetaDataIndexAliasesService.java
View File

@ -48,7 +48,6 @@ import java.util.Map;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
/** /**
* *
@ -103,7 +102,7 @@ public class MetaDataIndexAliasesService extends AbstractComponent {
} }
boolean changed = false; boolean changed = false;
MetaData.Builder builder = newMetaDataBuilder().metaData(currentState.metaData()); MetaData.Builder builder = MetaData.builder(currentState.metaData());
for (AliasAction aliasAction : request.actions) { for (AliasAction aliasAction : request.actions) {
IndexMetaData indexMetaData = builder.get(aliasAction.index()); IndexMetaData indexMetaData = builder.get(aliasAction.index());
if (indexMetaData == null) { if (indexMetaData == null) {

6
src/main/java/org/elasticsearch/cluster/metadata/MetaDataIndexStateService.java
View File

@ -113,8 +113,7 @@ public class MetaDataIndexStateService extends AbstractComponent {
logger.info("closing indices [{}]", indicesAsString); logger.info("closing indices [{}]", indicesAsString);
MetaData.Builder mdBuilder = MetaData.builder() MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
.metaData(currentState.metaData());
ClusterBlocks.Builder blocksBuilder = ClusterBlocks.builder() ClusterBlocks.Builder blocksBuilder = ClusterBlocks.builder()
.blocks(currentState.blocks()); .blocks(currentState.blocks());
for (String index : indicesToClose) { for (String index : indicesToClose) {
@ -185,8 +184,7 @@ public class MetaDataIndexStateService extends AbstractComponent {
logger.info("opening indices [{}]", indicesAsString); logger.info("opening indices [{}]", indicesAsString);
MetaData.Builder mdBuilder = MetaData.builder() MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
.metaData(currentState.metaData());
ClusterBlocks.Builder blocksBuilder = ClusterBlocks.builder() ClusterBlocks.Builder blocksBuilder = ClusterBlocks.builder()
.blocks(currentState.blocks()); .blocks(currentState.blocks());
for (String index : indicesToOpen) { for (String index : indicesToOpen) {

5
src/main/java/org/elasticsearch/cluster/metadata/MetaDataIndexTemplateService.java
View File

@ -85,7 +85,7 @@ public class MetaDataIndexTemplateService extends AbstractComponent {
} }
throw new IndexTemplateMissingException(request.name); throw new IndexTemplateMissingException(request.name);
} }
MetaData.Builder metaData = MetaData.builder().metaData(currentState.metaData()); MetaData.Builder metaData = MetaData.builder(currentState.metaData());
for (String templateName : templateNames) { for (String templateName : templateNames) {
metaData.removeTemplate(templateName); metaData.removeTemplate(templateName);
} }
@ -161,8 +161,7 @@ public class MetaDataIndexTemplateService extends AbstractComponent {
if (request.create && currentState.metaData().templates().containsKey(request.name)) { if (request.create && currentState.metaData().templates().containsKey(request.name)) {
throw new IndexTemplateAlreadyExistsException(request.name); throw new IndexTemplateAlreadyExistsException(request.name);
} }
MetaData.Builder builder = MetaData.builder().metaData(currentState.metaData()) MetaData.Builder builder = MetaData.builder(currentState.metaData()).put(template);
.put(template);
return ClusterState.builder().state(currentState).metaData(builder).build(); return ClusterState.builder().state(currentState).metaData(builder).build();
} }

7
src/main/java/org/elasticsearch/cluster/metadata/MetaDataMappingService.java
View File

@ -56,7 +56,6 @@ import java.util.concurrent.BlockingQueue;
import static com.google.common.collect.Maps.newHashMap; import static com.google.common.collect.Maps.newHashMap;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.index.mapper.DocumentMapper.MergeFlags.mergeFlags; import static org.elasticsearch.index.mapper.DocumentMapper.MergeFlags.mergeFlags;
/** /**
@ -142,7 +141,7 @@ public class MetaDataMappingService extends AbstractComponent {
} }
boolean dirty = false; boolean dirty = false;
MetaData.Builder mdBuilder = newMetaDataBuilder().metaData(currentState.metaData()); MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
for (Map.Entry<String, List<MappingTask>> entry : tasksPerIndex.entrySet()) { for (Map.Entry<String, List<MappingTask>> entry : tasksPerIndex.entrySet()) {
String index = entry.getKey(); String index = entry.getKey();
List<MappingTask> tasks = entry.getValue(); List<MappingTask> tasks = entry.getValue();
@ -334,7 +333,7 @@ public class MetaDataMappingService extends AbstractComponent {
throw new IndexMissingException(new Index("_all")); throw new IndexMissingException(new Index("_all"));
} }
MetaData.Builder builder = newMetaDataBuilder().metaData(currentState.metaData()); MetaData.Builder builder = MetaData.builder(currentState.metaData());
boolean changed = false; boolean changed = false;
String latestIndexWithout = null; String latestIndexWithout = null;
for (String indexName : request.indices()) { for (String indexName : request.indices()) {
@ -492,7 +491,7 @@ public class MetaDataMappingService extends AbstractComponent {
return currentState; return currentState;
} }
MetaData.Builder builder = newMetaDataBuilder().metaData(currentState.metaData()); MetaData.Builder builder = MetaData.builder(currentState.metaData());
for (String indexName : request.indices) { for (String indexName : request.indices) {
IndexMetaData indexMetaData = currentState.metaData().index(indexName); IndexMetaData indexMetaData = currentState.metaData().index(indexName);
if (indexMetaData == null) { if (indexMetaData == null) {

2
src/main/java/org/elasticsearch/cluster/metadata/MetaDataUpdateSettingsService.java
View File

@ -232,7 +232,7 @@ public class MetaDataUpdateSettingsService extends AbstractComponent implements
public ClusterState execute(ClusterState currentState) { public ClusterState execute(ClusterState currentState) {
String[] actualIndices = currentState.metaData().concreteIndices(request.indices()); String[] actualIndices = currentState.metaData().concreteIndices(request.indices());
RoutingTable.Builder routingTableBuilder = RoutingTable.builder().routingTable(currentState.routingTable()); RoutingTable.Builder routingTableBuilder = RoutingTable.builder().routingTable(currentState.routingTable());
MetaData.Builder metaDataBuilder = MetaData.newMetaDataBuilder().metaData(currentState.metaData()); MetaData.Builder metaDataBuilder = MetaData.builder(currentState.metaData());
// allow to change any settings to a close index, and only allow dynamic settings to be changed // allow to change any settings to a close index, and only allow dynamic settings to be changed
// on an open index // on an open index

4
src/main/java/org/elasticsearch/cluster/service/InternalClusterService.java
View File

@ -330,7 +330,7 @@ public class InternalClusterService extends AbstractLifecycleComponent<ClusterSe
builder.routingTable(RoutingTable.builder().routingTable(newClusterState.routingTable()).version(newClusterState.routingTable().version() + 1)); builder.routingTable(RoutingTable.builder().routingTable(newClusterState.routingTable()).version(newClusterState.routingTable().version() + 1));
} }
if (previousClusterState.metaData() != newClusterState.metaData()) { if (previousClusterState.metaData() != newClusterState.metaData()) {
builder.metaData(MetaData.builder().metaData(newClusterState.metaData()).version(newClusterState.metaData().version() + 1)); builder.metaData(MetaData.builder(newClusterState.metaData()).version(newClusterState.metaData().version() + 1));
} }
newClusterState = builder.build(); newClusterState = builder.build();
@ -356,7 +356,7 @@ public class InternalClusterService extends AbstractLifecycleComponent<ClusterSe
// have a fresh instances of routing and metadata to remove the chance that version might be the same // have a fresh instances of routing and metadata to remove the chance that version might be the same
Builder builder = ClusterState.builder().state(newClusterState); Builder builder = ClusterState.builder().state(newClusterState);
builder.routingTable(RoutingTable.builder().routingTable(newClusterState.routingTable())); builder.routingTable(RoutingTable.builder().routingTable(newClusterState.routingTable()));
builder.metaData(MetaData.builder().metaData(newClusterState.metaData())); builder.metaData(MetaData.builder(newClusterState.metaData()));
newClusterState = builder.build(); newClusterState = builder.build();
logger.debug("got first state from fresh master [{}]", newClusterState.nodes().masterNodeId()); logger.debug("got first state from fresh master [{}]", newClusterState.nodes().masterNodeId());
} else if (newClusterState.version() < previousClusterState.version()) { } else if (newClusterState.version() < previousClusterState.version()) {

2
src/main/java/org/elasticsearch/discovery/zen/ZenDiscovery.java
View File

@ -601,7 +601,7 @@ public class ZenDiscovery extends AbstractLifecycleComponent<Discovery> implemen
builder.metaData(currentState.metaData()); builder.metaData(currentState.metaData());
} else { } else {
// if its not the same version, only copy over new indices or ones that changed the version // if its not the same version, only copy over new indices or ones that changed the version
MetaData.Builder metaDataBuilder = MetaData.builder().metaData(newState.metaData()).removeAllIndices(); MetaData.Builder metaDataBuilder = MetaData.builder(newState.metaData()).removeAllIndices();
for (IndexMetaData indexMetaData : newState.metaData()) { for (IndexMetaData indexMetaData : newState.metaData()) {
IndexMetaData currentIndexMetaData = currentState.metaData().index(indexMetaData.index()); IndexMetaData currentIndexMetaData = currentState.metaData().index(indexMetaData.index());
if (currentIndexMetaData == null || currentIndexMetaData.version() != indexMetaData.version()) { if (currentIndexMetaData == null || currentIndexMetaData.version() != indexMetaData.version()) {

4
src/main/java/org/elasticsearch/gateway/GatewayService.java
View File

@ -43,7 +43,6 @@ import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicBoolean;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
/** /**
* *
@ -248,8 +247,7 @@ public class GatewayService extends AbstractLifecycleComponent<GatewayService> i
.blocks(recoveredState.blocks()) .blocks(recoveredState.blocks())
.removeGlobalBlock(STATE_NOT_RECOVERED_BLOCK); .removeGlobalBlock(STATE_NOT_RECOVERED_BLOCK);
MetaData.Builder metaDataBuilder = newMetaDataBuilder() MetaData.Builder metaDataBuilder = MetaData.builder(recoveredState.metaData());
.metaData(recoveredState.metaData());
if (recoveredState.metaData().settings().getAsBoolean(MetaData.SETTING_READ_ONLY, false) || currentState.metaData().settings().getAsBoolean(MetaData.SETTING_READ_ONLY, false)) { if (recoveredState.metaData().settings().getAsBoolean(MetaData.SETTING_READ_ONLY, false) || currentState.metaData().settings().getAsBoolean(MetaData.SETTING_READ_ONLY, false)) {
blocks.addGlobalBlock(MetaData.CLUSTER_READ_ONLY_BLOCK); blocks.addGlobalBlock(MetaData.CLUSTER_READ_ONLY_BLOCK);

3
src/main/java/org/elasticsearch/gateway/local/LocalGateway.java
View File

@ -135,7 +135,6 @@ public class LocalGateway extends AbstractLifecycleComponent<Gateway> implements
} }
} }
MetaData.Builder metaDataBuilder = MetaData.builder();
ObjectFloatOpenHashMap<String> indices = new ObjectFloatOpenHashMap<String>(); ObjectFloatOpenHashMap<String> indices = new ObjectFloatOpenHashMap<String>();
MetaData electedGlobalState = null; MetaData electedGlobalState = null;
int found = 0; int found = 0;
@ -158,7 +157,7 @@ public class LocalGateway extends AbstractLifecycleComponent<Gateway> implements
return; return;
} }
// update the global state, and clean the indices, we elect them in the next phase // update the global state, and clean the indices, we elect them in the next phase
metaDataBuilder.metaData(electedGlobalState).removeAllIndices(); MetaData.Builder metaDataBuilder = MetaData.builder(electedGlobalState).removeAllIndices();
final boolean[] states = indices.allocated; final boolean[] states = indices.allocated;
final Object[] keys = indices.keys; final Object[] keys = indices.keys;
for (int i = 0; i < states.length; i++) { for (int i = 0; i < states.length; i++) {

3
src/main/java/org/elasticsearch/gateway/local/state/meta/LocalAllocateDangledIndices.java
View File

@ -120,8 +120,7 @@ public class LocalAllocateDangledIndices extends AbstractComponent {
if (currentState.blocks().disableStatePersistence()) { if (currentState.blocks().disableStatePersistence()) {
return currentState; return currentState;
} }
MetaData.Builder metaData = MetaData.builder() MetaData.Builder metaData = MetaData.builder(currentState.metaData());
.metaData(currentState.metaData());
ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks()); ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks());
RoutingTable.Builder routingTableBuilder = RoutingTable.builder().routingTable(currentState.routingTable()); RoutingTable.Builder routingTableBuilder = RoutingTable.builder().routingTable(currentState.routingTable());

10
src/main/java/org/elasticsearch/gateway/local/state/meta/LocalGatewayMetaState.java
View File

@ -387,7 +387,7 @@ public class LocalGatewayMetaState extends AbstractComponent implements ClusterS
private void writeGlobalState(String reason, MetaData metaData, @Nullable MetaData previousMetaData) throws Exception { private void writeGlobalState(String reason, MetaData metaData, @Nullable MetaData previousMetaData) throws Exception {
logger.trace("[_global] writing state, reason [{}]", reason); logger.trace("[_global] writing state, reason [{}]", reason);
// create metadata to write with just the global state // create metadata to write with just the global state
MetaData globalMetaData = MetaData.builder().metaData(metaData).removeAllIndices().build(); MetaData globalMetaData = MetaData.builder(metaData).removeAllIndices().build();
XContentBuilder builder = XContentFactory.contentBuilder(format); XContentBuilder builder = XContentFactory.contentBuilder(format);
builder.startObject(); builder.startObject();
@ -442,10 +442,12 @@ public class LocalGatewayMetaState extends AbstractComponent implements ClusterS
} }
private MetaData loadState() throws Exception { private MetaData loadState() throws Exception {
MetaData.Builder metaDataBuilder = MetaData.builder();
MetaData globalMetaData = loadGlobalState(); MetaData globalMetaData = loadGlobalState();
MetaData.Builder metaDataBuilder;
if (globalMetaData != null) { if (globalMetaData != null) {
metaDataBuilder.metaData(globalMetaData); metaDataBuilder = MetaData.builder(globalMetaData);
} else {
metaDataBuilder = MetaData.builder();
} }
Set<String> indices = nodeEnv.findAllIndices(); Set<String> indices = nodeEnv.findAllIndices();
@ -618,7 +620,7 @@ public class LocalGatewayMetaState extends AbstractComponent implements ClusterS
logger.info("found old metadata state, loading metadata from [{}] and converting to new metadata location and strucutre...", metaDataFile.getAbsolutePath()); logger.info("found old metadata state, loading metadata from [{}] and converting to new metadata location and strucutre...", metaDataFile.getAbsolutePath());
writeGlobalState("upgrade", MetaData.builder().metaData(metaData).version(version).build(), null); writeGlobalState("upgrade", MetaData.builder(metaData).version(version).build(), null);
for (IndexMetaData indexMetaData : metaData) { for (IndexMetaData indexMetaData : metaData) {
IndexMetaData.Builder indexMetaDataBuilder = IndexMetaData.newIndexMetaDataBuilder(indexMetaData).version(version); IndexMetaData.Builder indexMetaDataBuilder = IndexMetaData.newIndexMetaDataBuilder(indexMetaData).version(version);
// set the created version to 0.18 // set the created version to 0.18

4
src/test/java/org/elasticsearch/cluster/metadata/ToAndFromJsonMetaDataTests.java
View File

@ -28,9 +28,7 @@ import java.io.IOException;
import static org.elasticsearch.cluster.metadata.AliasMetaData.newAliasMetaDataBuilder; import static org.elasticsearch.cluster.metadata.AliasMetaData.newAliasMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue; import static org.hamcrest.Matchers.nullValue;
@ -41,7 +39,7 @@ public class ToAndFromJsonMetaDataTests extends ElasticsearchTestCase {
@Test @Test
public void testSimpleJsonFromAndTo() throws IOException { public void testSimpleJsonFromAndTo() throws IOException {
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1") .put(newIndexMetaDataBuilder("test1")
.numberOfShards(1) .numberOfShards(1)
.numberOfReplicas(2)) .numberOfReplicas(2))

66
src/test/java/org/elasticsearch/cluster/routing/allocation/AddIncrementallyTests.java
View File

@ -19,14 +19,12 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED; import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
public class AddIncrementallyTests extends ElasticsearchTestCase { public class AddIncrementallyTests extends ElasticsearchTestCase {
private final ESLogger logger = Loggers.getLogger(AddIncrementallyTests.class); private final ESLogger logger = Loggers.getLogger(AddIncrementallyTests.class);
@ -53,7 +51,7 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertAtLeastOneIndexShardPerNode(clusterState); assertAtLeastOneIndexShardPerNode(clusterState);
clusterState = removeNodes(clusterState, service, 1); clusterState = removeNodes(clusterState, service, 1);
assertNumIndexShardsPerNode(clusterState, Matchers.equalTo(2)); assertNumIndexShardsPerNode(clusterState, Matchers.equalTo(2));
clusterState = addIndex(clusterState, service, 3, 2, 3); clusterState = addIndex(clusterState, service, 3, 2, 3);
assertThat(clusterState.routingNodes().getUnassigned().size(), Matchers.equalTo(2)); assertThat(clusterState.routingNodes().getUnassigned().size(), Matchers.equalTo(2));
assertNumIndexShardsPerNode(clusterState, "test3", Matchers.equalTo(2)); assertNumIndexShardsPerNode(clusterState, "test3", Matchers.equalTo(2));
@ -74,12 +72,12 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().getUnassigned().size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().getUnassigned().size(), Matchers.equalTo(0));
logger.debug("ClusterState: {}", clusterState.getRoutingNodes().prettyPrint()); logger.debug("ClusterState: {}", clusterState.getRoutingNodes().prettyPrint());
} }
@Test @Test
public void testMinimalRelocations() { public void testMinimalRelocations() {
ImmutableSettings.Builder settings = settingsBuilder(); ImmutableSettings.Builder settings = settingsBuilder();
settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()) settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString())
.put("cluster.routing.allocation.node_concurrent_recoveries", 2); .put("cluster.routing.allocation.node_concurrent_recoveries", 2);
AllocationService service = new AllocationService(settings.build()); AllocationService service = new AllocationService(settings.build());
ClusterState clusterState = initCluster(service, 1, 3, 3, 1); ClusterState clusterState = initCluster(service, 1, 3, 3, 1);
@ -91,10 +89,10 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), Matchers.equalTo(9)); assertThat(clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), Matchers.equalTo(9));
assertThat(clusterState.routingNodes().getUnassigned().size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().getUnassigned().size(), Matchers.equalTo(0));
assertNumIndexShardsPerNode(clusterState, Matchers.equalTo(3)); assertNumIndexShardsPerNode(clusterState, Matchers.equalTo(3));
logger.info("now, start one more node, check that rebalancing will happen because we set it to always"); logger.info("now, start one more node, check that rebalancing will happen because we set it to always");
DiscoveryNodes.Builder nodes = newNodesBuilder().putAll(clusterState.nodes()); DiscoveryNodes.Builder nodes = newNodesBuilder().putAll(clusterState.nodes());
nodes.put(newNode("node2")); nodes.put(newNode("node2"));
clusterState = newClusterStateBuilder().state(clusterState).nodes(nodes.build()).build(); clusterState = newClusterStateBuilder().state(clusterState).nodes(nodes.build()).build();
RoutingTable routingTable = service.reroute(clusterState).routingTable(); RoutingTable routingTable = service.reroute(clusterState).routingTable();
@ -115,7 +113,7 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable))); assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable)));
prev = routingTable; prev = routingTable;
routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
@ -125,7 +123,7 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable))); assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable)));
prev = routingTable; prev = routingTable;
routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
@ -135,7 +133,7 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable))); assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable)));
prev = routingTable; prev = routingTable;
routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
@ -144,13 +142,13 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertNumIndexShardsPerNode(clusterState, Matchers.equalTo(2)); assertNumIndexShardsPerNode(clusterState, Matchers.equalTo(2));
logger.debug("ClusterState: {}", clusterState.getRoutingNodes().prettyPrint()); logger.debug("ClusterState: {}", clusterState.getRoutingNodes().prettyPrint());
} }
@Test @Test
public void testMinimalRelocationsNoLimit() { public void testMinimalRelocationsNoLimit() {
ImmutableSettings.Builder settings = settingsBuilder(); ImmutableSettings.Builder settings = settingsBuilder();
settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()) settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString())
.put("cluster.routing.allocation.node_concurrent_recoveries", 100) .put("cluster.routing.allocation.node_concurrent_recoveries", 100)
.put("cluster.routing.allocation.node_initial_primaries_recoveries", 100); .put("cluster.routing.allocation.node_initial_primaries_recoveries", 100);
AllocationService service = new AllocationService(settings.build()); AllocationService service = new AllocationService(settings.build());
ClusterState clusterState = initCluster(service, 1, 3, 3, 1); ClusterState clusterState = initCluster(service, 1, 3, 3, 1);
@ -162,10 +160,10 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), Matchers.equalTo(9)); assertThat(clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), Matchers.equalTo(9));
assertThat(clusterState.routingNodes().getUnassigned().size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().getUnassigned().size(), Matchers.equalTo(0));
assertNumIndexShardsPerNode(clusterState, Matchers.equalTo(3)); assertNumIndexShardsPerNode(clusterState, Matchers.equalTo(3));
logger.info("now, start one more node, check that rebalancing will happen because we set it to always"); logger.info("now, start one more node, check that rebalancing will happen because we set it to always");
DiscoveryNodes.Builder nodes = newNodesBuilder().putAll(clusterState.nodes()); DiscoveryNodes.Builder nodes = newNodesBuilder().putAll(clusterState.nodes());
nodes.put(newNode("node2")); nodes.put(newNode("node2"));
clusterState = newClusterStateBuilder().state(clusterState).nodes(nodes.build()).build(); clusterState = newClusterStateBuilder().state(clusterState).nodes(nodes.build()).build();
RoutingTable routingTable = service.reroute(clusterState).routingTable(); RoutingTable routingTable = service.reroute(clusterState).routingTable();
@ -186,7 +184,7 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable))); assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable)));
prev = routingTable; prev = routingTable;
routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
@ -196,7 +194,7 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable))); assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable)));
prev = routingTable; prev = routingTable;
routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
@ -206,7 +204,7 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node0").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0)); assertThat(clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), Matchers.equalTo(0));
assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable))); assertThat(prev, Matchers.not(Matchers.sameInstance(routingTable)));
prev = routingTable; prev = routingTable;
routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
@ -222,14 +220,14 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
assertNumIndexShardsPerNode(state, index, matcher); assertNumIndexShardsPerNode(state, index, matcher);
} }
} }
private void assertNumIndexShardsPerNode(ClusterState state, String index, Matcher<Integer> matcher) { private void assertNumIndexShardsPerNode(ClusterState state, String index, Matcher<Integer> matcher) {
for (RoutingNode node : state.routingNodes()) { for (RoutingNode node : state.routingNodes()) {
assertThat(node.shardsWithState(index, STARTED).size(), matcher); assertThat(node.shardsWithState(index, STARTED).size(), matcher);
} }
} }
private void assertAtLeastOneIndexShardPerNode(ClusterState state) { private void assertAtLeastOneIndexShardPerNode(ClusterState state) {
for (String index : state.routingTable().indicesRouting().keySet()) { for (String index : state.routingTable().indicesRouting().keySet()) {
@ -270,8 +268,8 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
} }
private ClusterState initCluster(AllocationService service, int numberOfNodes, int numberOfIndices, int numberOfShards, private ClusterState initCluster(AllocationService service, int numberOfNodes, int numberOfIndices, int numberOfShards,
int numberOfReplicas) { int numberOfReplicas) {
MetaData.Builder metaDataBuilder = newMetaDataBuilder(); MetaData.Builder metaDataBuilder = MetaData.builder();
RoutingTable.Builder routingTableBuilder = routingTable(); RoutingTable.Builder routingTableBuilder = routingTable();
for (int i = 0; i < numberOfIndices; i++) { for (int i = 0; i < numberOfIndices; i++) {
@ -323,16 +321,16 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
return clusterState; return clusterState;
} }
private ClusterState addIndex(ClusterState clusterState, AllocationService service, int indexOrdinal, int numberOfShards, private ClusterState addIndex(ClusterState clusterState, AllocationService service, int indexOrdinal, int numberOfShards,
int numberOfReplicas) { int numberOfReplicas) {
MetaData.Builder metaDataBuilder = newMetaDataBuilder().metaData(clusterState.getMetaData()); MetaData.Builder metaDataBuilder = MetaData.builder(clusterState.getMetaData());
RoutingTable.Builder routingTableBuilder = routingTable().routingTable(clusterState.routingTable()); RoutingTable.Builder routingTableBuilder = routingTable().routingTable(clusterState.routingTable());
IndexMetaData.Builder index = newIndexMetaDataBuilder("test" + indexOrdinal).numberOfShards(numberOfShards).numberOfReplicas( IndexMetaData.Builder index = newIndexMetaDataBuilder("test" + indexOrdinal).numberOfShards(numberOfShards).numberOfReplicas(
numberOfReplicas); numberOfReplicas);
metaDataBuilder = metaDataBuilder.put(index); metaDataBuilder = metaDataBuilder.put(index);
routingTableBuilder.addAsNew(index.build()); routingTableBuilder.addAsNew(index.build());
MetaData metaData = metaDataBuilder.build(); MetaData metaData = metaDataBuilder.build();
RoutingTable routingTable = routingTableBuilder.build(); RoutingTable routingTable = routingTableBuilder.build();
@ -366,11 +364,11 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
return clusterState; return clusterState;
} }
private ClusterState removeNodes(ClusterState clusterState, AllocationService service, int numNodes) { private ClusterState removeNodes(ClusterState clusterState, AllocationService service, int numNodes) {
logger.info("Removing [{}] nodes", numNodes); logger.info("Removing [{}] nodes", numNodes);
DiscoveryNodes.Builder nodes = newNodesBuilder().putAll(clusterState.nodes()); DiscoveryNodes.Builder nodes = newNodesBuilder().putAll(clusterState.nodes());
for (DiscoveryNode node : clusterState.nodes()) { for (DiscoveryNode node : clusterState.nodes()) {
nodes.remove(node.id()); nodes.remove(node.id());
numNodes--; numNodes--;
@ -399,15 +397,15 @@ public class AddIncrementallyTests extends ElasticsearchTestCase {
logger.info("complete rebalancing"); logger.info("complete rebalancing");
RoutingTable prev = routingTable; RoutingTable prev = routingTable;
while(true) { while (true) {
routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
if (routingTable == prev) if (routingTable == prev)
break; break;
prev = routingTable; prev = routingTable;
} }
return clusterState; return clusterState;
} }
} }

4
src/test/java/org/elasticsearch/cluster/routing/allocation/AllocatePostApiFlagTests.java
View File

@ -29,13 +29,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -49,7 +47,7 @@ public class AllocatePostApiFlagTests extends ElasticsearchTestCase {
AllocationService allocation = new AllocationService(settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build()); AllocationService allocation = new AllocationService(settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build());
logger.info("creating an index with 1 shard, no replica"); logger.info("creating an index with 1 shard, no replica");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()

8
src/test/java/org/elasticsearch/cluster/routing/allocation/AllocationCommandsTests.java
View File

@ -42,14 +42,12 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED; import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -63,7 +61,7 @@ public class AllocationCommandsTests extends ElasticsearchTestCase {
AllocationService allocation = new AllocationService(settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build()); AllocationService allocation = new AllocationService(settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build());
logger.info("creating an index with 1 shard, no replica"); logger.info("creating an index with 1 shard, no replica");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()
@ -110,7 +108,7 @@ public class AllocationCommandsTests extends ElasticsearchTestCase {
.build()); .build());
logger.info("--> building initial routing table"); logger.info("--> building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()
@ -191,7 +189,7 @@ public class AllocationCommandsTests extends ElasticsearchTestCase {
.build()); .build());
logger.info("--> building initial routing table"); logger.info("--> building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()

28
src/test/java/org/elasticsearch/cluster/routing/allocation/AwarenessAllocationTests.java
View File

@ -32,7 +32,6 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
@ -56,7 +55,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded1'"); logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded1'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -125,7 +124,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded2'"); logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded2'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -200,7 +199,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded3'"); logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded3'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1))
.build(); .build();
@ -298,7 +297,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded4'"); logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded4'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(5).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(5).numberOfReplicas(1))
.build(); .build();
@ -381,6 +380,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("--> do another reroute, make sure nothing moves"); logger.info("--> do another reroute, make sure nothing moves");
assertThat(strategy.reroute(clusterState).routingTable(), sameInstance(clusterState.routingTable())); assertThat(strategy.reroute(clusterState).routingTable(), sameInstance(clusterState.routingTable()));
} }
@Test @Test
public void moveShardOnceNewNodeWithAttributeAdded5() { public void moveShardOnceNewNodeWithAttributeAdded5() {
AllocationService strategy = new AllocationService(settingsBuilder() AllocationService strategy = new AllocationService(settingsBuilder()
@ -391,7 +391,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded5'"); logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded5'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(2)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(2))
.build(); .build();
@ -470,7 +470,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded6'"); logger.info("Building initial routing table for 'moveShardOnceNewNodeWithAttributeAdded6'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(3)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(3))
.build(); .build();
@ -552,7 +552,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'fullAwareness1'"); logger.info("Building initial routing table for 'fullAwareness1'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -620,7 +620,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'fullAwareness2'"); logger.info("Building initial routing table for 'fullAwareness2'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -694,7 +694,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'fullAwareness3'"); logger.info("Building initial routing table for 'fullAwareness3'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(5).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(5).numberOfReplicas(1))
.build(); .build();
@ -762,7 +762,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("--> do another reroute, make sure nothing moves"); logger.info("--> do another reroute, make sure nothing moves");
assertThat(strategy.reroute(clusterState).routingTable(), sameInstance(clusterState.routingTable())); assertThat(strategy.reroute(clusterState).routingTable(), sameInstance(clusterState.routingTable()));
} }
@Test @Test
public void testUnbalancedZones() { public void testUnbalancedZones() {
AllocationService strategy = new AllocationService(settingsBuilder() AllocationService strategy = new AllocationService(settingsBuilder()
@ -776,7 +776,7 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table for 'testUnbalancedZones'"); logger.info("Building initial routing table for 'testUnbalancedZones'");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1))
.build(); .build();
@ -817,11 +817,11 @@ public class AwarenessAllocationTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(8)); assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(8));
assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size(), equalTo(2)); assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size(), equalTo(2));
assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).get(0).currentNodeId(), equalTo("A-1")); assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).get(0).currentNodeId(), equalTo("A-1"));
logger.info("--> starting inizializing shards on the new node"); logger.info("--> starting initializing shards on the new node");
routingTable = strategy.applyStartedShards(clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING)).routingTable(); routingTable = strategy.applyStartedShards(clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(10)); assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(10));
assertThat(clusterState.getRoutingNodes().node("A-1").shards().size(), equalTo(2)); assertThat(clusterState.getRoutingNodes().node("A-1").shards().size(), equalTo(2));
assertThat(clusterState.getRoutingNodes().node("A-0").shards().size(), equalTo(3)); assertThat(clusterState.getRoutingNodes().node("A-0").shards().size(), equalTo(3));

328
src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java
View File

@ -44,14 +44,12 @@ import java.util.List;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED; import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
public class BalanceConfigurationTests extends ElasticsearchTestCase { public class BalanceConfigurationTests extends ElasticsearchTestCase {
@ -61,7 +59,7 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
final int numberOfIndices = 12; final int numberOfIndices = 12;
final int numberOfShards = 2; final int numberOfShards = 2;
final int numberOfReplicas = 2; final int numberOfReplicas = 2;
@Test @Test
public void testIndexBalance() { public void testIndexBalance() {
/* Tests balance over indices only */ /* Tests balance over indices only */
@ -76,20 +74,20 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
settings.put(BalancedShardsAllocator.SETTING_SHARD_BALANCE_FACTOR, replicaBalance); settings.put(BalancedShardsAllocator.SETTING_SHARD_BALANCE_FACTOR, replicaBalance);
settings.put(BalancedShardsAllocator.SETTING_PRIMARY_BALANCE_FACTOR, primaryBalance); settings.put(BalancedShardsAllocator.SETTING_PRIMARY_BALANCE_FACTOR, primaryBalance);
settings.put(BalancedShardsAllocator.SETTING_THRESHOLD, balanceTreshold); settings.put(BalancedShardsAllocator.SETTING_THRESHOLD, balanceTreshold);
AllocationService strategy = new AllocationService(settings.build()); AllocationService strategy = new AllocationService(settings.build());
ClusterState clusterState = initCluster(strategy); ClusterState clusterState = initCluster(strategy);
assertIndexBalance(logger, clusterState.getRoutingNodes(), numberOfNodes, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertIndexBalance(logger, clusterState.getRoutingNodes(), numberOfNodes, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
clusterState = addNode(clusterState, strategy); clusterState = addNode(clusterState, strategy);
assertIndexBalance(logger, clusterState.getRoutingNodes(), numberOfNodes+1, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertIndexBalance(logger, clusterState.getRoutingNodes(), numberOfNodes + 1, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
clusterState = removeNodes(clusterState, strategy); clusterState = removeNodes(clusterState, strategy);
assertIndexBalance(logger, clusterState.getRoutingNodes(), (numberOfNodes+1)-(numberOfNodes+1)/2, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertIndexBalance(logger, clusterState.getRoutingNodes(), (numberOfNodes + 1) - (numberOfNodes + 1) / 2, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
} }
@Test @Test
public void testReplicaBalance() { public void testReplicaBalance() {
/* Tests balance over replicas only */ /* Tests balance over replicas only */
@ -97,27 +95,27 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
final float replicaBalance = 1.0f; final float replicaBalance = 1.0f;
final float primaryBalance = 0.0f; final float primaryBalance = 0.0f;
final float balanceTreshold = 1.0f; final float balanceTreshold = 1.0f;
ImmutableSettings.Builder settings = settingsBuilder(); ImmutableSettings.Builder settings = settingsBuilder();
settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()); settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString());
settings.put(BalancedShardsAllocator.SETTING_INDEX_BALANCE_FACTOR, indexBalance); settings.put(BalancedShardsAllocator.SETTING_INDEX_BALANCE_FACTOR, indexBalance);
settings.put(BalancedShardsAllocator.SETTING_SHARD_BALANCE_FACTOR, replicaBalance); settings.put(BalancedShardsAllocator.SETTING_SHARD_BALANCE_FACTOR, replicaBalance);
settings.put(BalancedShardsAllocator.SETTING_PRIMARY_BALANCE_FACTOR, primaryBalance); settings.put(BalancedShardsAllocator.SETTING_PRIMARY_BALANCE_FACTOR, primaryBalance);
settings.put(BalancedShardsAllocator.SETTING_THRESHOLD, balanceTreshold); settings.put(BalancedShardsAllocator.SETTING_THRESHOLD, balanceTreshold);
AllocationService strategy = new AllocationService(settings.build()); AllocationService strategy = new AllocationService(settings.build());
ClusterState clusterState = initCluster(strategy); ClusterState clusterState = initCluster(strategy);
assertReplicaBalance(logger, clusterState.getRoutingNodes(), numberOfNodes, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertReplicaBalance(logger, clusterState.getRoutingNodes(), numberOfNodes, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
clusterState = addNode(clusterState, strategy); clusterState = addNode(clusterState, strategy);
assertReplicaBalance(logger, clusterState.getRoutingNodes(), numberOfNodes+1, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertReplicaBalance(logger, clusterState.getRoutingNodes(), numberOfNodes + 1, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
clusterState = removeNodes(clusterState, strategy); clusterState = removeNodes(clusterState, strategy);
assertReplicaBalance(logger, clusterState.getRoutingNodes(), (numberOfNodes+1)-(numberOfNodes+1)/2, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertReplicaBalance(logger, clusterState.getRoutingNodes(), (numberOfNodes + 1) - (numberOfNodes + 1) / 2, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
} }
@Test @Test
public void testPrimaryBalance() { public void testPrimaryBalance() {
/* Tests balance over primaries only */ /* Tests balance over primaries only */
@ -125,48 +123,48 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
final float replicaBalance = 0.0f; final float replicaBalance = 0.0f;
final float primaryBalance = 1.0f; final float primaryBalance = 1.0f;
final float balanceTreshold = 1.0f; final float balanceTreshold = 1.0f;
ImmutableSettings.Builder settings = settingsBuilder(); ImmutableSettings.Builder settings = settingsBuilder();
settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()); settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString());
settings.put(BalancedShardsAllocator.SETTING_INDEX_BALANCE_FACTOR, indexBalance); settings.put(BalancedShardsAllocator.SETTING_INDEX_BALANCE_FACTOR, indexBalance);
settings.put(BalancedShardsAllocator.SETTING_SHARD_BALANCE_FACTOR, replicaBalance); settings.put(BalancedShardsAllocator.SETTING_SHARD_BALANCE_FACTOR, replicaBalance);
settings.put(BalancedShardsAllocator.SETTING_PRIMARY_BALANCE_FACTOR, primaryBalance); settings.put(BalancedShardsAllocator.SETTING_PRIMARY_BALANCE_FACTOR, primaryBalance);
settings.put(BalancedShardsAllocator.SETTING_THRESHOLD, balanceTreshold); settings.put(BalancedShardsAllocator.SETTING_THRESHOLD, balanceTreshold);
AllocationService strategy = new AllocationService(settings.build()); AllocationService strategy = new AllocationService(settings.build());
ClusterState clusterstate = initCluster(strategy); ClusterState clusterstate = initCluster(strategy);
assertPrimaryBalance(logger, clusterstate.getRoutingNodes(), numberOfNodes, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertPrimaryBalance(logger, clusterstate.getRoutingNodes(), numberOfNodes, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
clusterstate = addNode(clusterstate, strategy); clusterstate = addNode(clusterstate, strategy);
assertPrimaryBalance(logger, clusterstate.getRoutingNodes(), numberOfNodes+1, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertPrimaryBalance(logger, clusterstate.getRoutingNodes(), numberOfNodes + 1, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
clusterstate = removeNodes(clusterstate, strategy); clusterstate = removeNodes(clusterstate, strategy);
assertPrimaryBalance(logger, clusterstate.getRoutingNodes(), numberOfNodes+1-(numberOfNodes+1)/2, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold); assertPrimaryBalance(logger, clusterstate.getRoutingNodes(), numberOfNodes + 1 - (numberOfNodes + 1) / 2, numberOfIndices, numberOfReplicas, numberOfShards, balanceTreshold);
} }
private ClusterState initCluster(AllocationService strategy) { private ClusterState initCluster(AllocationService strategy) {
MetaData.Builder metaDataBuilder = newMetaDataBuilder(); MetaData.Builder metaDataBuilder = MetaData.builder();
RoutingTable.Builder routingTableBuilder = routingTable(); RoutingTable.Builder routingTableBuilder = routingTable();
for (int i = 0; i < numberOfIndices; i++) { for (int i = 0; i < numberOfIndices; i++) {
IndexMetaData.Builder index = newIndexMetaDataBuilder("test"+i).numberOfShards(numberOfShards).numberOfReplicas(numberOfReplicas); IndexMetaData.Builder index = newIndexMetaDataBuilder("test" + i).numberOfShards(numberOfShards).numberOfReplicas(numberOfReplicas);
metaDataBuilder = metaDataBuilder.put(index); metaDataBuilder = metaDataBuilder.put(index);
} }
MetaData metaData = metaDataBuilder.build(); MetaData metaData = metaDataBuilder.build();
for (IndexMetaData index : metaData.indices().values()) { for (IndexMetaData index : metaData.indices().values()) {
routingTableBuilder.addAsNew(index); routingTableBuilder.addAsNew(index);
} }
RoutingTable routingTable = routingTableBuilder.build(); RoutingTable routingTable = routingTableBuilder.build();
logger.info("start "+numberOfNodes+" nodes"); logger.info("start " + numberOfNodes + " nodes");
DiscoveryNodes.Builder nodes = newNodesBuilder(); DiscoveryNodes.Builder nodes = newNodesBuilder();
for (int i = 0; i < numberOfNodes; i++) { for (int i = 0; i < numberOfNodes; i++) {
nodes.put(newNode("node"+i)); nodes.put(newNode("node" + i));
} }
ClusterState clusterState = newClusterStateBuilder().nodes(nodes).metaData(metaData).routingTable(routingTable).build(); ClusterState clusterState = newClusterStateBuilder().nodes(nodes).metaData(metaData).routingTable(routingTable).build();
routingTable = strategy.reroute(clusterState).routingTable(); routingTable = strategy.reroute(clusterState).routingTable();
@ -184,25 +182,25 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
logger.info("complete rebalancing"); logger.info("complete rebalancing");
RoutingTable prev = routingTable; RoutingTable prev = routingTable;
while(true) { while (true) {
routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
if (routingTable == prev) if (routingTable == prev)
break; break;
prev = routingTable; prev = routingTable;
} }
return clusterState; return clusterState;
} }
private ClusterState addNode(ClusterState clusterState, AllocationService strategy) { private ClusterState addNode(ClusterState clusterState, AllocationService strategy) {
logger.info("now, start 1 more node, check that rebalancing will happen because we set it to always"); logger.info("now, start 1 more node, check that rebalancing will happen because we set it to always");
clusterState = newClusterStateBuilder().state(clusterState).nodes(newNodesBuilder().putAll(clusterState.nodes()) clusterState = newClusterStateBuilder().state(clusterState).nodes(newNodesBuilder().putAll(clusterState.nodes())
.put(newNode("node"+numberOfNodes))) .put(newNode("node" + numberOfNodes)))
.build(); .build();
RoutingTable routingTable = strategy.reroute(clusterState).routingTable(); RoutingTable routingTable = strategy.reroute(clusterState).routingTable();
@ -210,26 +208,26 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
RoutingNodes routingNodes = clusterState.routingNodes(); RoutingNodes routingNodes = clusterState.routingNodes();
// move initializing to started // move initializing to started
RoutingTable prev = routingTable; RoutingTable prev = routingTable;
while(true) { while (true) {
routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
if (routingTable == prev) if (routingTable == prev)
break; break;
prev = routingTable; prev = routingTable;
} }
return clusterState; return clusterState;
} }
private ClusterState removeNodes(ClusterState clusterState, AllocationService strategy) { private ClusterState removeNodes(ClusterState clusterState, AllocationService strategy) {
logger.info("Removing half the nodes ("+(numberOfNodes+1)/2+")"); logger.info("Removing half the nodes (" + (numberOfNodes + 1) / 2 + ")");
DiscoveryNodes.Builder nodes = newNodesBuilder().putAll(clusterState.nodes()); DiscoveryNodes.Builder nodes = newNodesBuilder().putAll(clusterState.nodes());
for(int i=(numberOfNodes+1)/2; i<=numberOfNodes; i++){ for (int i = (numberOfNodes + 1) / 2; i <= numberOfNodes; i++) {
nodes.remove("node"+i); nodes.remove("node" + i);
} }
clusterState = newClusterStateBuilder().state(clusterState).nodes(nodes.build()).build(); clusterState = newClusterStateBuilder().state(clusterState).nodes(nodes.build()).build();
@ -252,25 +250,25 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
logger.info("complete rebalancing"); logger.info("complete rebalancing");
RoutingTable prev = routingTable; RoutingTable prev = routingTable;
while(true) { while (true) {
routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
if (routingTable == prev) if (routingTable == prev)
break; break;
prev = routingTable; prev = routingTable;
} }
return clusterState; return clusterState;
} }
private void assertReplicaBalance(ESLogger logger, RoutingNodes nodes, int numberOfNodes, int numberOfIndices, int numberOfReplicas, int numberOfShards, float treshold) { private void assertReplicaBalance(ESLogger logger, RoutingNodes nodes, int numberOfNodes, int numberOfIndices, int numberOfReplicas, int numberOfShards, float treshold) {
final int numShards = numberOfIndices * numberOfShards * (numberOfReplicas+1); final int numShards = numberOfIndices * numberOfShards * (numberOfReplicas + 1);
final float avgNumShards = (float)(numShards) / (float)(numberOfNodes); final float avgNumShards = (float) (numShards) / (float) (numberOfNodes);
final int minAvgNumberOfShards = Math.round(Math.round(Math.floor(avgNumShards-treshold))); final int minAvgNumberOfShards = Math.round(Math.round(Math.floor(avgNumShards - treshold)));
final int maxAvgNumberOfShards = Math.round(Math.round(Math.ceil(avgNumShards+treshold))); final int maxAvgNumberOfShards = Math.round(Math.round(Math.ceil(avgNumShards + treshold)));
for (RoutingNode node : nodes) { for (RoutingNode node : nodes) {
// logger.info(node.nodeId() + ": " + node.shardsWithState(INITIALIZING, STARTED).size() + " shards ("+minAvgNumberOfShards+" to "+maxAvgNumberOfShards+")"); // logger.info(node.nodeId() + ": " + node.shardsWithState(INITIALIZING, STARTED).size() + " shards ("+minAvgNumberOfShards+" to "+maxAvgNumberOfShards+")");
assertThat(node.shardsWithState(STARTED).size(), Matchers.greaterThanOrEqualTo(minAvgNumberOfShards)); assertThat(node.shardsWithState(STARTED).size(), Matchers.greaterThanOrEqualTo(minAvgNumberOfShards));
@ -279,13 +277,13 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
} }
private void assertIndexBalance(ESLogger logger, RoutingNodes nodes, int numberOfNodes, int numberOfIndices, int numberOfReplicas, int numberOfShards, float treshold) { private void assertIndexBalance(ESLogger logger, RoutingNodes nodes, int numberOfNodes, int numberOfIndices, int numberOfReplicas, int numberOfShards, float treshold) {
final int numShards = numberOfShards * (numberOfReplicas+1);
final float avgNumShards = (float)(numShards) / (float)(numberOfNodes);
final int minAvgNumberOfShards = Math.round(Math.round(Math.floor(avgNumShards-treshold)));
final int maxAvgNumberOfShards = Math.round(Math.round(Math.ceil(avgNumShards+treshold)));
for(String index : nodes.getRoutingTable().indicesRouting().keySet()) { final int numShards = numberOfShards * (numberOfReplicas + 1);
final float avgNumShards = (float) (numShards) / (float) (numberOfNodes);
final int minAvgNumberOfShards = Math.round(Math.round(Math.floor(avgNumShards - treshold)));
final int maxAvgNumberOfShards = Math.round(Math.round(Math.ceil(avgNumShards + treshold)));
for (String index : nodes.getRoutingTable().indicesRouting().keySet()) {
for (RoutingNode node : nodes) { for (RoutingNode node : nodes) {
// logger.info(node.nodeId() +":"+index+ ": " + node.shardsWithState(index, INITIALIZING, STARTED).size() + " shards ("+minAvgNumberOfShards+" to "+maxAvgNumberOfShards+")"); // logger.info(node.nodeId() +":"+index+ ": " + node.shardsWithState(index, INITIALIZING, STARTED).size() + " shards ("+minAvgNumberOfShards+" to "+maxAvgNumberOfShards+")");
assertThat(node.shardsWithState(index, STARTED).size(), Matchers.greaterThanOrEqualTo(minAvgNumberOfShards)); assertThat(node.shardsWithState(index, STARTED).size(), Matchers.greaterThanOrEqualTo(minAvgNumberOfShards));
@ -293,19 +291,19 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
} }
} }
} }
private void assertPrimaryBalance(ESLogger logger, RoutingNodes nodes, int numberOfNodes, int numberOfIndices, int numberOfReplicas, int numberOfShards, float treshold) {
final int numShards = numberOfShards;
final float avgNumShards = (float)(numShards) / (float)(numberOfNodes);
final int minAvgNumberOfShards = Math.round(Math.round(Math.floor(avgNumShards-treshold)));
final int maxAvgNumberOfShards = Math.round(Math.round(Math.ceil(avgNumShards+treshold)));
for(String index : nodes.getRoutingTable().indicesRouting().keySet()) { private void assertPrimaryBalance(ESLogger logger, RoutingNodes nodes, int numberOfNodes, int numberOfIndices, int numberOfReplicas, int numberOfShards, float treshold) {
final int numShards = numberOfShards;
final float avgNumShards = (float) (numShards) / (float) (numberOfNodes);
final int minAvgNumberOfShards = Math.round(Math.round(Math.floor(avgNumShards - treshold)));
final int maxAvgNumberOfShards = Math.round(Math.round(Math.ceil(avgNumShards + treshold)));
for (String index : nodes.getRoutingTable().indicesRouting().keySet()) {
for (RoutingNode node : nodes) { for (RoutingNode node : nodes) {
int primaries = 0; int primaries = 0;
for(ShardRouting shard : node.shardsWithState(index, STARTED)) { for (ShardRouting shard : node.shardsWithState(index, STARTED)) {
primaries += shard.primary()?1:0; primaries += shard.primary() ? 1 : 0;
} }
// logger.info(node.nodeId() + ": " + primaries + " primaries ("+minAvgNumberOfShards+" to "+maxAvgNumberOfShards+")"); // logger.info(node.nodeId() + ": " + primaries + " primaries ("+minAvgNumberOfShards+" to "+maxAvgNumberOfShards+")");
assertThat(primaries, Matchers.greaterThanOrEqualTo(minAvgNumberOfShards)); assertThat(primaries, Matchers.greaterThanOrEqualTo(minAvgNumberOfShards));
@ -313,7 +311,7 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
} }
} }
} }
@Test @Test
public void testPersistedSettings() { public void testPersistedSettings() {
ImmutableSettings.Builder settings = settingsBuilder(); ImmutableSettings.Builder settings = settingsBuilder();
@ -327,16 +325,16 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
@Override @Override
public void addListener(Listener listener) { public void addListener(Listener listener) {
assert listeners[0] == null; assert listeners[0] == null;
listeners[0] = listener; listeners[0] = listener;
} }
}; };
BalancedShardsAllocator allocator = new BalancedShardsAllocator(settings.build(), service); BalancedShardsAllocator allocator = new BalancedShardsAllocator(settings.build(), service);
assertThat(allocator.getIndexBalance(), Matchers.equalTo(0.2f)); assertThat(allocator.getIndexBalance(), Matchers.equalTo(0.2f));
assertThat(allocator.getShardBalance(), Matchers.equalTo(0.3f)); assertThat(allocator.getShardBalance(), Matchers.equalTo(0.3f));
assertThat(allocator.getPrimaryBalance(), Matchers.equalTo(0.5f)); assertThat(allocator.getPrimaryBalance(), Matchers.equalTo(0.5f));
assertThat(allocator.getThreshold(), Matchers.equalTo(2.0f)); assertThat(allocator.getThreshold(), Matchers.equalTo(2.0f));
settings = settingsBuilder(); settings = settingsBuilder();
settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()); settings.put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString());
listeners[0].onRefreshSettings(settings.build()); listeners[0].onRefreshSettings(settings.build());
@ -344,7 +342,7 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
assertThat(allocator.getShardBalance(), Matchers.equalTo(0.3f)); assertThat(allocator.getShardBalance(), Matchers.equalTo(0.3f));
assertThat(allocator.getPrimaryBalance(), Matchers.equalTo(0.5f)); assertThat(allocator.getPrimaryBalance(), Matchers.equalTo(0.5f));
assertThat(allocator.getThreshold(), Matchers.equalTo(2.0f)); assertThat(allocator.getThreshold(), Matchers.equalTo(2.0f));
settings = settingsBuilder(); settings = settingsBuilder();
settings.put(BalancedShardsAllocator.SETTING_INDEX_BALANCE_FACTOR, 0.5); settings.put(BalancedShardsAllocator.SETTING_INDEX_BALANCE_FACTOR, 0.5);
settings.put(BalancedShardsAllocator.SETTING_SHARD_BALANCE_FACTOR, 0.1); settings.put(BalancedShardsAllocator.SETTING_SHARD_BALANCE_FACTOR, 0.1);
@ -356,7 +354,7 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
assertThat(allocator.getPrimaryBalance(), Matchers.equalTo(0.4f)); assertThat(allocator.getPrimaryBalance(), Matchers.equalTo(0.4f));
assertThat(allocator.getThreshold(), Matchers.equalTo(3.0f)); assertThat(allocator.getThreshold(), Matchers.equalTo(3.0f));
} }
@Test @Test
public void testNoRebalanceOnPrimaryOverload() { public void testNoRebalanceOnPrimaryOverload() {
@ -365,96 +363,96 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
new NodeSettingsService(ImmutableSettings.Builder.EMPTY_SETTINGS)), new ShardsAllocators(settings.build(), new NodeSettingsService(ImmutableSettings.Builder.EMPTY_SETTINGS)), new ShardsAllocators(settings.build(),
new NoneGatewayAllocator(), new ShardsAllocator() { new NoneGatewayAllocator(), new ShardsAllocator() {
@Override @Override
public boolean rebalance(RoutingAllocation allocation) { public boolean rebalance(RoutingAllocation allocation) {
return false; return false;
} }
@Override @Override
public boolean move(MutableShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) { public boolean move(MutableShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
return false; return false;
} }
@Override @Override
public void applyStartedShards(StartedRerouteAllocation allocation) { public void applyStartedShards(StartedRerouteAllocation allocation) {
}
@Override
public void applyFailedShards(FailedRerouteAllocation allocation) { }
}
@Override
/* public void applyFailedShards(FailedRerouteAllocation allocation) {
* // this allocator tries to rebuild this scenario where a rebalance is }
* // triggered solely by the primary overload on node [1] where a shard
* // is rebalanced to node 0 /*
routing_nodes: * // this allocator tries to rebuild this scenario where a rebalance is
-----node_id[0][V] * // triggered solely by the primary overload on node [1] where a shard
--------[test][0], node[0], [R], s[STARTED] * // is rebalanced to node 0
--------[test][4], node[0], [R], s[STARTED] routing_nodes:
-----node_id[1][V] -----node_id[0][V]
--------[test][0], node[1], [P], s[STARTED] --------[test][0], node[0], [R], s[STARTED]
--------[test][1], node[1], [P], s[STARTED] --------[test][4], node[0], [R], s[STARTED]
--------[test][3], node[1], [R], s[STARTED] -----node_id[1][V]
-----node_id[2][V] --------[test][0], node[1], [P], s[STARTED]
--------[test][1], node[2], [R], s[STARTED] --------[test][1], node[1], [P], s[STARTED]
--------[test][2], node[2], [R], s[STARTED] --------[test][3], node[1], [R], s[STARTED]
--------[test][4], node[2], [P], s[STARTED] -----node_id[2][V]
-----node_id[3][V] --------[test][1], node[2], [R], s[STARTED]
--------[test][2], node[3], [P], s[STARTED] --------[test][2], node[2], [R], s[STARTED]
--------[test][3], node[3], [P], s[STARTED] --------[test][4], node[2], [P], s[STARTED]
---- unassigned -----node_id[3][V]
*/ --------[test][2], node[3], [P], s[STARTED]
@Override --------[test][3], node[3], [P], s[STARTED]
public boolean allocateUnassigned(RoutingAllocation allocation) { ---- unassigned
List<MutableShardRouting> unassigned = allocation.routingNodes().unassigned(); */
boolean changed = !unassigned.isEmpty(); @Override
for (MutableShardRouting sr : unassigned) { public boolean allocateUnassigned(RoutingAllocation allocation) {
switch (sr.id()) { List<MutableShardRouting> unassigned = allocation.routingNodes().unassigned();
case 0: boolean changed = !unassigned.isEmpty();
if (sr.primary()) { for (MutableShardRouting sr : unassigned) {
allocation.routingNodes().node("node1").add(sr); switch (sr.id()) {
} else { case 0:
allocation.routingNodes().node("node0").add(sr); if (sr.primary()) {
} allocation.routingNodes().node("node1").add(sr);
break; } else {
case 1: allocation.routingNodes().node("node0").add(sr);
if (sr.primary()) {
allocation.routingNodes().node("node1").add(sr);
} else {
allocation.routingNodes().node("node2").add(sr);
}
break;
case 2:
if (sr.primary()) {
allocation.routingNodes().node("node3").add(sr);
} else {
allocation.routingNodes().node("node2").add(sr);
}
break;
case 3:
if (sr.primary()) {
allocation.routingNodes().node("node3").add(sr);
} else {
allocation.routingNodes().node("node1").add(sr);
}
break;
case 4:
if (sr.primary()) {
allocation.routingNodes().node("node2").add(sr);
} else {
allocation.routingNodes().node("node0").add(sr);
}
break;
} }
break;
} case 1:
unassigned.clear(); if (sr.primary()) {
return changed; allocation.routingNodes().node("node1").add(sr);
} else {
allocation.routingNodes().node("node2").add(sr);
}
break;
case 2:
if (sr.primary()) {
allocation.routingNodes().node("node3").add(sr);
} else {
allocation.routingNodes().node("node2").add(sr);
}
break;
case 3:
if (sr.primary()) {
allocation.routingNodes().node("node3").add(sr);
} else {
allocation.routingNodes().node("node1").add(sr);
}
break;
case 4:
if (sr.primary()) {
allocation.routingNodes().node("node2").add(sr);
} else {
allocation.routingNodes().node("node0").add(sr);
}
break;
} }
}), ClusterInfoService.EMPTY);
MetaData.Builder metaDataBuilder = newMetaDataBuilder(); }
unassigned.clear();
return changed;
}
}), ClusterInfoService.EMPTY);
MetaData.Builder metaDataBuilder = MetaData.builder();
RoutingTable.Builder routingTableBuilder = routingTable(); RoutingTable.Builder routingTableBuilder = routingTable();
IndexMetaData.Builder indexMeta = newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1); IndexMetaData.Builder indexMeta = newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1);
metaDataBuilder = metaDataBuilder.put(indexMeta); metaDataBuilder = metaDataBuilder.put(indexMeta);
@ -465,15 +463,15 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
RoutingTable routingTable = routingTableBuilder.build(); RoutingTable routingTable = routingTableBuilder.build();
DiscoveryNodes.Builder nodes = newNodesBuilder(); DiscoveryNodes.Builder nodes = newNodesBuilder();
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
DiscoveryNode node = newNode("node"+i); DiscoveryNode node = newNode("node" + i);
nodes.put(node); nodes.put(node);
} }
ClusterState clusterState = newClusterStateBuilder().nodes(nodes).metaData(metaData).routingTable(routingTable).build(); ClusterState clusterState = newClusterStateBuilder().nodes(nodes).metaData(metaData).routingTable(routingTable).build();
routingTable = strategy.reroute(clusterState).routingTable(); routingTable = strategy.reroute(clusterState).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
RoutingNodes routingNodes = clusterState.routingNodes(); RoutingNodes routingNodes = clusterState.routingNodes();
for (RoutingNode routingNode : routingNodes) { for (RoutingNode routingNode : routingNodes) {
for (MutableShardRouting mutableShardRouting : routingNode) { for (MutableShardRouting mutableShardRouting : routingNode) {
assertThat(mutableShardRouting.state(), Matchers.equalTo(ShardRoutingState.INITIALIZING)); assertThat(mutableShardRouting.state(), Matchers.equalTo(ShardRoutingState.INITIALIZING));
@ -491,12 +489,12 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
assertThat(mutableShardRouting.state(), Matchers.equalTo(ShardRoutingState.STARTED)); assertThat(mutableShardRouting.state(), Matchers.equalTo(ShardRoutingState.STARTED));
} }
} }
logger.info("start the replica shards"); logger.info("start the replica shards");
routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable(); routingTable = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING)).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
for (RoutingNode routingNode : routingNodes) { for (RoutingNode routingNode : routingNodes) {
for (MutableShardRouting mutableShardRouting : routingNode) { for (MutableShardRouting mutableShardRouting : routingNode) {
assertThat(mutableShardRouting.state(), Matchers.equalTo(ShardRoutingState.STARTED)); assertThat(mutableShardRouting.state(), Matchers.equalTo(ShardRoutingState.STARTED));
@ -507,13 +505,13 @@ public class BalanceConfigurationTests extends ElasticsearchTestCase {
routingTable = strategy.reroute(clusterState).routingTable(); routingTable = strategy.reroute(clusterState).routingTable();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
for (RoutingNode routingNode : routingNodes) { for (RoutingNode routingNode : routingNodes) {
for (MutableShardRouting mutableShardRouting : routingNode) { for (MutableShardRouting mutableShardRouting : routingNode) {
assertThat(mutableShardRouting.state(), Matchers.equalTo(ShardRoutingState.STARTED)); assertThat(mutableShardRouting.state(), Matchers.equalTo(ShardRoutingState.STARTED));
} }
} }
} }
} }

14
src/test/java/org/elasticsearch/cluster/routing/allocation/ClusterRebalanceRoutingTests.java
View File

@ -31,13 +31,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
public class ClusterRebalanceRoutingTests extends ElasticsearchTestCase { public class ClusterRebalanceRoutingTests extends ElasticsearchTestCase {
@ -48,7 +46,7 @@ public class ClusterRebalanceRoutingTests extends ElasticsearchTestCase {
public void testAlways() { public void testAlways() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -134,7 +132,7 @@ public class ClusterRebalanceRoutingTests extends ElasticsearchTestCase {
public void testClusterPrimariesActive1() { public void testClusterPrimariesActive1() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_PRIMARIES_ACTIVE.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_PRIMARIES_ACTIVE.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -238,7 +236,7 @@ public class ClusterRebalanceRoutingTests extends ElasticsearchTestCase {
public void testClusterPrimariesActive2() { public void testClusterPrimariesActive2() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_PRIMARIES_ACTIVE.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_PRIMARIES_ACTIVE.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -322,7 +320,7 @@ public class ClusterRebalanceRoutingTests extends ElasticsearchTestCase {
public void testClusterAllActive1() { public void testClusterAllActive1() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_ALL_ACTIVE.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_ALL_ACTIVE.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -445,7 +443,7 @@ public class ClusterRebalanceRoutingTests extends ElasticsearchTestCase {
public void testClusterAllActive2() { public void testClusterAllActive2() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_ALL_ACTIVE.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_ALL_ACTIVE.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -529,7 +527,7 @@ public class ClusterRebalanceRoutingTests extends ElasticsearchTestCase {
public void testClusterAllActive3() { public void testClusterAllActive3() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_ALL_ACTIVE.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.INDICES_ALL_ACTIVE.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();

4
src/test/java/org/elasticsearch/cluster/routing/allocation/ConcurrentRebalanceRoutingTests.java
View File

@ -30,13 +30,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue; import static org.hamcrest.Matchers.nullValue;
@ -53,7 +51,7 @@ public class ConcurrentRebalanceRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1))
.build(); .build();

8
src/test/java/org/elasticsearch/cluster/routing/allocation/DeadNodesAllocationTests.java
View File

@ -31,13 +31,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -54,7 +52,7 @@ public class DeadNodesAllocationTests extends ElasticsearchTestCase {
.build()); .build());
logger.info("--> building initial routing table"); logger.info("--> building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()
@ -106,7 +104,7 @@ public class DeadNodesAllocationTests extends ElasticsearchTestCase {
.build()); .build());
logger.info("--> building initial routing table"); logger.info("--> building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()
@ -181,7 +179,7 @@ public class DeadNodesAllocationTests extends ElasticsearchTestCase {
.build()); .build());
logger.info("--> building initial routing table"); logger.info("--> building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()

8
src/test/java/org/elasticsearch/cluster/routing/allocation/DisableAllocationTests.java
View File

@ -31,14 +31,12 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED; import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -56,7 +54,7 @@ public class DisableAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -85,7 +83,7 @@ public class DisableAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -116,7 +114,7 @@ public class DisableAllocationTests extends ElasticsearchTestCase {
AllocationService strategy = new AllocationService(settingsBuilder() AllocationService strategy = new AllocationService(settingsBuilder()
.build()); .build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("disabled").settings(ImmutableSettings.builder().put(DisableAllocationDecider.INDEX_ROUTING_ALLOCATION_DISABLE_ALLOCATION, true).put(DisableAllocationDecider.INDEX_ROUTING_ALLOCATION_DISABLE_NEW_ALLOCATION, true)).numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("disabled").settings(ImmutableSettings.builder().put(DisableAllocationDecider.INDEX_ROUTING_ALLOCATION_DISABLE_ALLOCATION, true).put(DisableAllocationDecider.INDEX_ROUTING_ALLOCATION_DISABLE_NEW_ALLOCATION, true)).numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("enabled").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("enabled").numberOfShards(1).numberOfReplicas(1))
.build(); .build();

4
src/test/java/org/elasticsearch/cluster/routing/allocation/ElectReplicaAsPrimaryDuringRelocationTests.java
View File

@ -31,14 +31,12 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED; import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -54,7 +52,7 @@ public class ElectReplicaAsPrimaryDuringRelocationTests extends ElasticsearchTes
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1))
.build(); .build();

6
src/test/java/org/elasticsearch/cluster/routing/allocation/FailedNodeRoutingTests.java
View File

@ -32,14 +32,12 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED; import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
public class FailedNodeRoutingTests extends ElasticsearchTestCase { public class FailedNodeRoutingTests extends ElasticsearchTestCase {
@ -50,7 +48,7 @@ public class FailedNodeRoutingTests extends ElasticsearchTestCase {
public void simpleFailedNodeTest() { public void simpleFailedNodeTest() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -110,7 +108,7 @@ public class FailedNodeRoutingTests extends ElasticsearchTestCase {
public void simpleFailedNodeTestNoReassign() { public void simpleFailedNodeTestNoReassign() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();

12
src/test/java/org/elasticsearch/cluster/routing/allocation/FailedShardsRoutingTests.java
View File

@ -34,13 +34,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.*;
/** /**
@ -58,7 +56,7 @@ public class FailedShardsRoutingTests extends ElasticsearchTestCase {
.build()); .build());
logger.info("--> building initial routing table"); logger.info("--> building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()
@ -148,7 +146,7 @@ public class FailedShardsRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -229,7 +227,7 @@ public class FailedShardsRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -286,7 +284,7 @@ public class FailedShardsRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -343,7 +341,7 @@ public class FailedShardsRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1))
.build(); .build();

8
src/test/java/org/elasticsearch/cluster/routing/allocation/FilterRoutingTests.java
View File

@ -35,13 +35,11 @@ import java.util.List;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -59,7 +57,7 @@ public class FilterRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1))
.build(); .build();
@ -103,7 +101,7 @@ public class FilterRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").settings(settingsBuilder() .put(newIndexMetaDataBuilder("test").settings(settingsBuilder()
.put("index.number_of_shards", 2) .put("index.number_of_shards", 2)
.put("index.number_of_replicas", 1) .put("index.number_of_replicas", 1)
@ -146,7 +144,7 @@ public class FilterRoutingTests extends ElasticsearchTestCase {
logger.info("--> switch between value2 and value4, shards should be relocating"); logger.info("--> switch between value2 and value4, shards should be relocating");
metaData = newMetaDataBuilder() metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").settings(settingsBuilder() .put(newIndexMetaDataBuilder("test").settings(settingsBuilder()
.put("index.number_of_shards", 2) .put("index.number_of_shards", 2)
.put("index.number_of_replicas", 1) .put("index.number_of_replicas", 1)

14
src/test/java/org/elasticsearch/cluster/routing/allocation/IndexBalanceTests.java
View File

@ -32,13 +32,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue; import static org.hamcrest.Matchers.nullValue;
@ -59,7 +57,7 @@ public class IndexBalanceTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder().put(newIndexMetaDataBuilder("test").numberOfShards(3).numberOfReplicas(1)) MetaData metaData = MetaData.builder().put(newIndexMetaDataBuilder("test").numberOfShards(3).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test1").numberOfShards(3).numberOfReplicas(1)).build(); .put(newIndexMetaDataBuilder("test1").numberOfShards(3).numberOfReplicas(1)).build();
RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).addAsNew(metaData.index("test1")).build(); RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).addAsNew(metaData.index("test1")).build();
@ -190,7 +188,7 @@ public class IndexBalanceTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder().put(newIndexMetaDataBuilder("test").numberOfShards(3).numberOfReplicas(1)) MetaData metaData = MetaData.builder().put(newIndexMetaDataBuilder("test").numberOfShards(3).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test1").numberOfShards(3).numberOfReplicas(1)).build(); .put(newIndexMetaDataBuilder("test1").numberOfShards(3).numberOfReplicas(1)).build();
RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).addAsNew(metaData.index("test1")).build(); RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).addAsNew(metaData.index("test1")).build();
@ -353,7 +351,7 @@ public class IndexBalanceTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder().put(newIndexMetaDataBuilder("test").numberOfShards(3).numberOfReplicas(1)).build(); MetaData metaData = MetaData.builder().put(newIndexMetaDataBuilder("test").numberOfShards(3).numberOfReplicas(1)).build();
RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).build(); RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).build();
@ -451,7 +449,7 @@ public class IndexBalanceTests extends ElasticsearchTestCase {
logger.info("Add new index 3 shards 1 replica"); logger.info("Add new index 3 shards 1 replica");
prevRoutingTable = routingTable; prevRoutingTable = routingTable;
metaData = newMetaDataBuilder().metaData(metaData) metaData = MetaData.builder(metaData)
.put(newIndexMetaDataBuilder("test1").settings(ImmutableSettings.settingsBuilder() .put(newIndexMetaDataBuilder("test1").settings(ImmutableSettings.settingsBuilder()
.put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 3) .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 3)
.put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1) .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1)
@ -461,8 +459,8 @@ public class IndexBalanceTests extends ElasticsearchTestCase {
.addAsNew(metaData.index("test1")) .addAsNew(metaData.index("test1"))
.build(); .build();
clusterState = newClusterStateBuilder().state(clusterState).metaData(metaData).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).metaData(metaData).routingTable(routingTable).build();
assertThat(routingTable.index("test1").shards().size(), equalTo(3)); assertThat(routingTable.index("test1").shards().size(), equalTo(3));
prevRoutingTable = routingTable; prevRoutingTable = routingTable;

7
src/test/java/org/elasticsearch/cluster/routing/allocation/PreferPrimaryAllocationTests.java
View File

@ -29,7 +29,6 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
@ -53,7 +52,7 @@ public class PreferPrimaryAllocationTests extends ElasticsearchTestCase {
logger.info("create several indices with no replicas, and wait till all are allocated"); logger.info("create several indices with no replicas, and wait till all are allocated");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(10).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("test1").numberOfShards(10).numberOfReplicas(0))
.put(newIndexMetaDataBuilder("test2").numberOfShards(10).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("test2").numberOfShards(10).numberOfReplicas(0))
.build(); .build();
@ -77,7 +76,7 @@ public class PreferPrimaryAllocationTests extends ElasticsearchTestCase {
logger.info("increasing the number of replicas to 1, and perform a reroute (to get the replicas allocation going)"); logger.info("increasing the number of replicas to 1, and perform a reroute (to get the replicas allocation going)");
routingTable = RoutingTable.builder().routingTable(routingTable).updateNumberOfReplicas(1).build(); routingTable = RoutingTable.builder().routingTable(routingTable).updateNumberOfReplicas(1).build();
metaData = MetaData.newMetaDataBuilder().metaData(clusterState.metaData()).updateNumberOfReplicas(1).build(); metaData = MetaData.builder(clusterState.metaData()).updateNumberOfReplicas(1).build();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).metaData(metaData).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).metaData(metaData).build();
routingTable = strategy.reroute(clusterState).routingTable(); routingTable = strategy.reroute(clusterState).routingTable();
@ -87,7 +86,7 @@ public class PreferPrimaryAllocationTests extends ElasticsearchTestCase {
assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(2)); assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(2));
logger.info("create a new index"); logger.info("create a new index");
metaData = newMetaDataBuilder().metaData(clusterState.metaData()) metaData = MetaData.builder(clusterState.metaData())
.put(newIndexMetaDataBuilder("new_index").numberOfShards(4).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("new_index").numberOfShards(4).numberOfReplicas(0))
.build(); .build();

6
src/test/java/org/elasticsearch/cluster/routing/allocation/PrimaryElectionRoutingTests.java
View File

@ -30,14 +30,12 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED; import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue; import static org.hamcrest.Matchers.nullValue;
@ -54,7 +52,7 @@ public class PrimaryElectionRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -105,7 +103,7 @@ public class PrimaryElectionRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1))
.build(); .build();

4
src/test/java/org/elasticsearch/cluster/routing/allocation/PrimaryNotRelocatedWhileBeingRecoveredTests.java
View File

@ -30,14 +30,12 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED; import static org.elasticsearch.cluster.routing.ShardRoutingState.STARTED;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -57,7 +55,7 @@ public class PrimaryNotRelocatedWhileBeingRecoveredTests extends ElasticsearchTe
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1))
.build(); .build();

47
src/test/java/org/elasticsearch/cluster/routing/allocation/RandomAllocationDeciderTests.java
View File

@ -44,7 +44,6 @@ import java.util.Random;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
@ -60,20 +59,20 @@ public class RandomAllocationDeciderTests extends ElasticsearchTestCase {
* already allocated on a node and balances the cluster to gain optimal * already allocated on a node and balances the cluster to gain optimal
* balance.*/ * balance.*/
@Test @Test
public void testRandomDecicions() { public void testRandomDecisions() {
RandomAllocationDecider randomAllocationDecider = new RandomAllocationDecider(getRandom()); RandomAllocationDecider randomAllocationDecider = new RandomAllocationDecider(getRandom());
AllocationService strategy = new AllocationService(settingsBuilder().build(), new AllocationDeciders(ImmutableSettings.EMPTY, AllocationService strategy = new AllocationService(settingsBuilder().build(), new AllocationDeciders(ImmutableSettings.EMPTY,
new HashSet<AllocationDecider>(Arrays.asList(new SameShardAllocationDecider(ImmutableSettings.EMPTY), new HashSet<AllocationDecider>(Arrays.asList(new SameShardAllocationDecider(ImmutableSettings.EMPTY),
randomAllocationDecider))), new ShardsAllocators(), ClusterInfoService.EMPTY); randomAllocationDecider))), new ShardsAllocators(), ClusterInfoService.EMPTY);
int indices = between(1, 20); int indices = between(1, 20);
Builder metaBuilder = newMetaDataBuilder(); Builder metaBuilder = MetaData.builder();
int maxNumReplicas = 1; int maxNumReplicas = 1;
int totalNumShards = 0; int totalNumShards = 0;
for (int i = 0; i < indices; i++) { for (int i = 0; i < indices; i++) {
int replicas = between(0, 6); int replicas = between(0, 6);
maxNumReplicas = Math.max(maxNumReplicas, replicas+1); maxNumReplicas = Math.max(maxNumReplicas, replicas + 1);
int numShards = between(1, 20); int numShards = between(1, 20);
totalNumShards += numShards * (replicas+1); totalNumShards += numShards * (replicas + 1);
metaBuilder.put(newIndexMetaDataBuilder("INDEX_" + i).numberOfShards(numShards).numberOfReplicas(replicas)); metaBuilder.put(newIndexMetaDataBuilder("INDEX_" + i).numberOfShards(numShards).numberOfReplicas(replicas));
} }
@ -94,7 +93,7 @@ public class RandomAllocationDeciderTests extends ElasticsearchTestCase {
DiscoveryNodes.Builder newNodesBuilder = newNodesBuilder(); DiscoveryNodes.Builder newNodesBuilder = newNodesBuilder();
newNodesBuilder.putAll(clusterState.nodes()); newNodesBuilder.putAll(clusterState.nodes());
if (clusterState.nodes().size() <= atMostNodes && if (clusterState.nodes().size() <= atMostNodes &&
(nodeIdCounter == 0 || (frequentNodes ? frequently() : rarely()))) { (nodeIdCounter == 0 || (frequentNodes ? frequently() : rarely()))) {
int numNodes = atLeast(1); int numNodes = atLeast(1);
for (int j = 0; j < numNodes; j++) { for (int j = 0; j < numNodes; j++) {
@ -124,14 +123,14 @@ public class RandomAllocationDeciderTests extends ElasticsearchTestCase {
ClusterState.Builder stateBuilder = newClusterStateBuilder().state(clusterState); ClusterState.Builder stateBuilder = newClusterStateBuilder().state(clusterState);
DiscoveryNodes.Builder newNodesBuilder = newNodesBuilder(); DiscoveryNodes.Builder newNodesBuilder = newNodesBuilder();
newNodesBuilder.putAll(clusterState.nodes()); newNodesBuilder.putAll(clusterState.nodes());
for (int j = 0; j < (maxNumReplicas-clusterState.nodes().size()); j++) { for (int j = 0; j < (maxNumReplicas - clusterState.nodes().size()); j++) {
logger.info("adding node [{}]", nodeIdCounter); logger.info("adding node [{}]", nodeIdCounter);
newNodesBuilder.put(newNode("NODE_" + (nodeIdCounter++))); newNodesBuilder.put(newNode("NODE_" + (nodeIdCounter++)));
} }
stateBuilder.nodes(newNodesBuilder.build()); stateBuilder.nodes(newNodesBuilder.build());
clusterState = stateBuilder.build(); clusterState = stateBuilder.build();
} }
randomAllocationDecider.allwaysSayYes = true; randomAllocationDecider.allwaysSayYes = true;
logger.info("now say YES to everything"); logger.info("now say YES to everything");
@ -146,11 +145,11 @@ public class RandomAllocationDeciderTests extends ElasticsearchTestCase {
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
} }
} while (clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size() != 0 || } while (clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size() != 0 ||
clusterState.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED).size() != 0 && iterations < 200); clusterState.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED).size() != 0 && iterations < 200);
logger.info("Done Balancing after [{}] iterations", iterations); logger.info("Done Balancing after [{}] iterations", iterations);
// we stop after 200 iterations if it didn't stabelize by then something is likely to be wrong // we stop after 200 iterations if it didn't stabelize by then something is likely to be wrong
assertThat("max num iteration exceeded", iterations, Matchers.lessThan(200)); assertThat("max num iteration exceeded", iterations, Matchers.lessThan(200));
assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size(), equalTo(0)); assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size(), equalTo(0));
assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED).size(), equalTo(0)); assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED).size(), equalTo(0));
int shards = clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(); int shards = clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size();
@ -189,20 +188,20 @@ public class RandomAllocationDeciderTests extends ElasticsearchTestCase {
return Decision.YES; return Decision.YES;
} }
switch (random.nextInt(10)) { switch (random.nextInt(10)) {
case 9: case 9:
case 8: case 8:
case 7: case 7:
case 6: case 6:
case 5: case 5:
return Decision.NO; return Decision.NO;
case 4: case 4:
return Decision.THROTTLE; return Decision.THROTTLE;
case 3: case 3:
case 2: case 2:
case 1: case 1:
return Decision.YES; return Decision.YES;
default: default:
return Decision.ALWAYS; return Decision.ALWAYS;
} }
} }

4
src/test/java/org/elasticsearch/cluster/routing/allocation/RebalanceAfterActiveTests.java
View File

@ -31,13 +31,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue; import static org.hamcrest.Matchers.nullValue;
@ -58,7 +56,7 @@ public class RebalanceAfterActiveTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1))
.build(); .build();

4
src/test/java/org/elasticsearch/cluster/routing/allocation/ReplicaAllocatedAfterPrimaryTests.java
View File

@ -30,13 +30,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue; import static org.hamcrest.Matchers.nullValue;
@ -53,7 +51,7 @@ public class ReplicaAllocatedAfterPrimaryTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();

3
src/test/java/org/elasticsearch/cluster/routing/allocation/SameShardRoutingTests.java
View File

@ -14,7 +14,6 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
@ -32,7 +31,7 @@ public class SameShardRoutingTests extends ElasticsearchTestCase {
public void sameHost() { public void sameHost() {
AllocationService strategy = new AllocationService(settingsBuilder().put(SameShardAllocationDecider.SAME_HOST_SETTING, true).build()); AllocationService strategy = new AllocationService(settingsBuilder().put(SameShardAllocationDecider.SAME_HOST_SETTING, true).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1))
.build(); .build();

4
src/test/java/org/elasticsearch/cluster/routing/allocation/ShardVersioningTests.java
View File

@ -31,13 +31,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
public class ShardVersioningTests extends ElasticsearchTestCase { public class ShardVersioningTests extends ElasticsearchTestCase {
@ -48,7 +46,7 @@ public class ShardVersioningTests extends ElasticsearchTestCase {
public void simple() { public void simple() {
AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()).build()); AllocationService strategy = new AllocationService(settingsBuilder().put("cluster.routing.allocation.allow_rebalance", ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()).build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();

10
src/test/java/org/elasticsearch/cluster/routing/allocation/ShardsLimitAllocationTests.java
View File

@ -35,13 +35,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -56,7 +54,7 @@ public class ShardsLimitAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").settings(ImmutableSettings.settingsBuilder() .put(newIndexMetaDataBuilder("test").settings(ImmutableSettings.settingsBuilder()
.put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 4) .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 4)
.put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1) .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1)
@ -106,7 +104,7 @@ public class ShardsLimitAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").settings(ImmutableSettings.settingsBuilder() .put(newIndexMetaDataBuilder("test").settings(ImmutableSettings.settingsBuilder()
.put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5) .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5)
.put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0) .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0)
@ -131,7 +129,7 @@ public class ShardsLimitAllocationTests extends ElasticsearchTestCase {
assertThat(clusterState.readOnlyRoutingNodes().numberOfShardsOfType(STARTED), equalTo(5)); assertThat(clusterState.readOnlyRoutingNodes().numberOfShardsOfType(STARTED), equalTo(5));
logger.info("add another index with 5 shards"); logger.info("add another index with 5 shards");
metaData = newMetaDataBuilder().metaData(metaData) metaData = MetaData.builder(metaData)
.put(newIndexMetaDataBuilder("test1").settings(ImmutableSettings.settingsBuilder() .put(newIndexMetaDataBuilder("test1").settings(ImmutableSettings.settingsBuilder()
.put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5) .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5)
.put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0) .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0)
@ -162,7 +160,7 @@ public class ShardsLimitAllocationTests extends ElasticsearchTestCase {
} }
logger.info("update " + ShardsLimitAllocationDecider.INDEX_TOTAL_SHARDS_PER_NODE + " for test, see that things move"); logger.info("update " + ShardsLimitAllocationDecider.INDEX_TOTAL_SHARDS_PER_NODE + " for test, see that things move");
metaData = newMetaDataBuilder().metaData(metaData) metaData = MetaData.builder(metaData)
.put(newIndexMetaDataBuilder("test").settings(ImmutableSettings.settingsBuilder() .put(newIndexMetaDataBuilder("test").settings(ImmutableSettings.settingsBuilder()
.put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5) .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5)
.put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0) .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0)

10
src/test/java/org/elasticsearch/cluster/routing/allocation/SingleShardNoReplicasRoutingTests.java
View File

@ -39,13 +39,11 @@ import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Sets.newHashSet; import static com.google.common.collect.Sets.newHashSet;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.*;
/** /**
@ -61,7 +59,7 @@ public class SingleShardNoReplicasRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0))
.build(); .build();
@ -163,7 +161,7 @@ public class SingleShardNoReplicasRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0))
.build(); .build();
@ -218,7 +216,7 @@ public class SingleShardNoReplicasRoutingTests extends ElasticsearchTestCase {
final int numberOfIndices = 50; final int numberOfIndices = 50;
logger.info("Building initial routing table with " + numberOfIndices + " indices"); logger.info("Building initial routing table with " + numberOfIndices + " indices");
MetaData.Builder metaDataBuilder = newMetaDataBuilder(); MetaData.Builder metaDataBuilder = MetaData.builder();
for (int i = 0; i < numberOfIndices; i++) { for (int i = 0; i < numberOfIndices; i++) {
metaDataBuilder.put(newIndexMetaDataBuilder("test" + i).numberOfShards(1).numberOfReplicas(0)); metaDataBuilder.put(newIndexMetaDataBuilder("test" + i).numberOfShards(1).numberOfReplicas(0));
} }
@ -331,7 +329,7 @@ public class SingleShardNoReplicasRoutingTests extends ElasticsearchTestCase {
final int numberOfIndices = 10; final int numberOfIndices = 10;
logger.info("Building initial routing table with " + numberOfIndices + " indices"); logger.info("Building initial routing table with " + numberOfIndices + " indices");
MetaData.Builder metaDataBuilder = newMetaDataBuilder(); MetaData.Builder metaDataBuilder = MetaData.builder();
for (int i = 0; i < numberOfIndices; i++) { for (int i = 0; i < numberOfIndices; i++) {
metaDataBuilder.put(newIndexMetaDataBuilder("test" + i).numberOfShards(1).numberOfReplicas(0)); metaDataBuilder.put(newIndexMetaDataBuilder("test" + i).numberOfShards(1).numberOfReplicas(0));
} }

4
src/test/java/org/elasticsearch/cluster/routing/allocation/SingleShardOneReplicaRoutingTests.java
View File

@ -30,13 +30,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue; import static org.hamcrest.Matchers.nullValue;
@ -53,7 +51,7 @@ public class SingleShardOneReplicaRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();

4
src/test/java/org/elasticsearch/cluster/routing/allocation/TenShardsOneReplicaRoutingTests.java
View File

@ -30,13 +30,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.*;
/** /**
@ -60,7 +58,7 @@ public class TenShardsOneReplicaRoutingTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1))
.build(); .build();

6
src/test/java/org/elasticsearch/cluster/routing/allocation/ThrottlingAllocationTests.java
View File

@ -29,13 +29,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -54,7 +52,7 @@ public class ThrottlingAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1))
.build(); .build();
@ -115,7 +113,7 @@ public class ThrottlingAllocationTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1))
.build(); .build();

8
src/test/java/org/elasticsearch/cluster/routing/allocation/UpdateNumberOfReplicasTests.java
View File

@ -11,13 +11,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.*;
/** /**
@ -33,7 +31,7 @@ public class UpdateNumberOfReplicasTests extends ElasticsearchTestCase {
logger.info("Building initial routing table"); logger.info("Building initial routing table");
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -85,7 +83,7 @@ public class UpdateNumberOfReplicasTests extends ElasticsearchTestCase {
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
prevRoutingTable = routingTable; prevRoutingTable = routingTable;
routingTable = RoutingTable.builder().routingTable(routingTable).updateNumberOfReplicas(2).build(); routingTable = RoutingTable.builder().routingTable(routingTable).updateNumberOfReplicas(2).build();
metaData = MetaData.newMetaDataBuilder().metaData(clusterState.metaData()).updateNumberOfReplicas(2).build(); metaData = MetaData.builder(clusterState.metaData()).updateNumberOfReplicas(2).build();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).metaData(metaData).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).metaData(metaData).build();
assertThat(clusterState.metaData().index("test").numberOfReplicas(), equalTo(2)); assertThat(clusterState.metaData().index("test").numberOfReplicas(), equalTo(2));
@ -137,7 +135,7 @@ public class UpdateNumberOfReplicasTests extends ElasticsearchTestCase {
routingNodes = clusterState.routingNodes(); routingNodes = clusterState.routingNodes();
prevRoutingTable = routingTable; prevRoutingTable = routingTable;
routingTable = RoutingTable.builder().routingTable(routingTable).updateNumberOfReplicas(1).build(); routingTable = RoutingTable.builder().routingTable(routingTable).updateNumberOfReplicas(1).build();
metaData = MetaData.newMetaDataBuilder().metaData(clusterState.metaData()).updateNumberOfReplicas(1).build(); metaData = MetaData.builder(clusterState.metaData()).updateNumberOfReplicas(1).build();
clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).metaData(metaData).build(); clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).metaData(metaData).build();
assertThat(clusterState.metaData().index("test").numberOfReplicas(), equalTo(1)); assertThat(clusterState.metaData().index("test").numberOfReplicas(), equalTo(1));

9
src/test/java/org/elasticsearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java
View File

@ -41,7 +41,6 @@ import java.util.Map;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.*; import static org.elasticsearch.cluster.routing.ShardRoutingState.*;
@ -88,7 +87,7 @@ public class DiskThresholdDeciderTests extends ElasticsearchTestCase {
.put("cluster.routing.allocation.cluster_concurrent_rebalance", -1) .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
.build(), deciders, new ShardsAllocators(), cis); .build(), deciders, new ShardsAllocators(), cis);
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -277,7 +276,7 @@ public class DiskThresholdDeciderTests extends ElasticsearchTestCase {
.put("cluster.routing.allocation.cluster_concurrent_rebalance", -1) .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
.build(), deciders, new ShardsAllocators(), cis); .build(), deciders, new ShardsAllocators(), cis);
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -463,7 +462,7 @@ public class DiskThresholdDeciderTests extends ElasticsearchTestCase {
.put("cluster.routing.allocation.cluster_concurrent_rebalance", -1) .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
.build(), deciders, new ShardsAllocators(), cis); .build(), deciders, new ShardsAllocators(), cis);
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0))
.build(); .build();
@ -525,7 +524,7 @@ public class DiskThresholdDeciderTests extends ElasticsearchTestCase {
.put("cluster.routing.allocation.cluster_concurrent_rebalance", -1) .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
.build(), deciders, new ShardsAllocators(), cis); .build(), deciders, new ShardsAllocators(), cis);
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0))
.build(); .build();

6
src/test/java/org/elasticsearch/cluster/serialization/ClusterSerializationTests.java
View File

@ -34,9 +34,7 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
/** /**
@ -46,7 +44,7 @@ public class ClusterSerializationTests extends ElasticsearchTestCase {
@Test @Test
public void testClusterStateSerialization() throws Exception { public void testClusterStateSerialization() throws Exception {
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1))
.build(); .build();
@ -69,7 +67,7 @@ public class ClusterSerializationTests extends ElasticsearchTestCase {
@Test @Test
public void testRoutingTableSerialization() throws Exception { public void testRoutingTableSerialization() throws Exception {
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1))
.build(); .build();

12
src/test/java/org/elasticsearch/cluster/structure/RoutingIteratorTests.java
View File

@ -35,13 +35,11 @@ import org.junit.Test;
import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder; import static org.elasticsearch.cluster.ClusterState.newClusterStateBuilder;
import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder; import static org.elasticsearch.cluster.metadata.IndexMetaData.newIndexMetaDataBuilder;
import static org.elasticsearch.cluster.metadata.MetaData.newMetaDataBuilder;
import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder; import static org.elasticsearch.cluster.node.DiscoveryNodes.newNodesBuilder;
import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable; import static org.elasticsearch.cluster.routing.RoutingBuilders.routingTable;
import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING; import static org.elasticsearch.cluster.routing.ShardRoutingState.INITIALIZING;
import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode; import static org.elasticsearch.cluster.routing.allocation.RoutingAllocationTests.newNode;
import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder; import static org.elasticsearch.common.settings.ImmutableSettings.settingsBuilder;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.*;
public class RoutingIteratorTests extends ElasticsearchTestCase { public class RoutingIteratorTests extends ElasticsearchTestCase {
@ -87,7 +85,7 @@ public class RoutingIteratorTests extends ElasticsearchTestCase {
@Test @Test
public void testIterator1() { public void testIterator1() {
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(2)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(2))
.build(); .build();
RoutingTable routingTable = routingTable() RoutingTable routingTable = routingTable()
@ -121,7 +119,7 @@ public class RoutingIteratorTests extends ElasticsearchTestCase {
@Test @Test
public void testIterator2() { public void testIterator2() {
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -224,7 +222,7 @@ public class RoutingIteratorTests extends ElasticsearchTestCase {
@Test @Test
public void testRandomRouting() { public void testRandomRouting() {
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test1").numberOfShards(1).numberOfReplicas(1))
.put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test2").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -258,7 +256,7 @@ public class RoutingIteratorTests extends ElasticsearchTestCase {
.put("cluster.routing.allocation.awareness.attributes", "rack_id,zone") .put("cluster.routing.allocation.awareness.attributes", "rack_id,zone")
.build()); .build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
.build(); .build();
@ -307,7 +305,7 @@ public class RoutingIteratorTests extends ElasticsearchTestCase {
.put("cluster.routing.allocation.concurrent_recoveries", 10) .put("cluster.routing.allocation.concurrent_recoveries", 10)
.build()); .build());
MetaData metaData = newMetaDataBuilder() MetaData metaData = MetaData.builder()
.put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1)) .put(newIndexMetaDataBuilder("test").numberOfShards(5).numberOfReplicas(1))
.build(); .build();