@Test public void index_with_source() { NewIndex index = new NewIndex("issues", defaultSettingsConfiguration); NewIndex.NewIndexType mapping = index.createType("issue"); mapping.setEnableSource(true); mapping = index.getTypes().get("issue"); assertThat(mapping).isNotNull(); assertThat(getAttributeAsMap(mapping, "_source")).containsExactly(entry("enabled", true)); }
@Test public void in_standalone_searchReplicas_is_not_overridable() { settings.setProperty(SEARCH_REPLICAS.getKey(), "5"); NewIndex index = new NewIndex("issues", defaultSettingsConfiguration); assertThat(index.getSettings().get("index.number_of_replicas")).isEqualTo("0"); }
Index(NewIndex newIndex) { this.name = newIndex.getName(); this.settings = newIndex.getSettings().build(); ImmutableMap.Builder<String, Type> builder = ImmutableMap.builder(); for (NewIndex.NewIndexType newIndexType : newIndex.getTypes().values()) { Type type = new Type(newIndexType); builder.put(type.getName(), type); } this.types = builder.build(); }
/** * Creates a type that requires to verify that user has the read permission * when searching for documents. * * Both types {@code typeName} and "authorization" are created. Documents * must be created with _parent and _routing having the parent uuid as values. * * @see NewIndex.NewIndexType#requireProjectAuthorization() */ private static NewIndex.NewIndexType enableProjectAuthorization(NewIndex.NewIndexType type) { type.setAttribute("_parent", ImmutableMap.of("type", TYPE_AUTHORIZATION)); type.setAttribute("_routing", ImmutableMap.of("required", true)); NewIndex.NewIndexType authType = type.getIndex().createType(TYPE_AUTHORIZATION); authType.setAttribute("_routing", ImmutableMap.of("required", true)); authType.createLongField(FIELD_GROUP_IDS); authType.createLongField(FIELD_USER_IDS); authType.createBooleanField(FIELD_ALLOW_ANYONE); authType.setEnableSource(false); return type; }
@Test public void use_doc_values_by_default() { NewIndex index = new NewIndex("issues", defaultSettingsConfiguration); NewIndex.NewIndexType mapping = index.createType("issue"); mapping.keywordFieldBuilder("the_doc_value").build(); Map<String, Object> props = (Map) mapping.getProperty("the_doc_value"); assertThat(props.get("type")).isEqualTo("keyword"); assertThat(props.get("doc_values")).isEqualTo("true"); }
@Test public void test_definition_of_index() { IndexDefinition.IndexDefinitionContext context = new IndexDefinition.IndexDefinitionContext(); underTest.define(context); assertThat(context.getIndices()).hasSize(1); NewIndex ruleIndex = context.getIndices().get("rules"); assertThat(ruleIndex).isNotNull(); assertThat(ruleIndex.getTypes().keySet()).containsOnly("activeRule", "ruleExtension", "rule"); // no cluster by default assertThat(ruleIndex.getSettings().get("index.number_of_shards")).isEqualTo("2"); assertThat(ruleIndex.getSettings().get("index.number_of_replicas")).isEqualTo("0"); }
@Override public void define(IndexDefinitionContext context) { NewIndex index = context.create(INDEX, newBuilder(new MapSettings().asConfig()).build()); index.getSettings().put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, replicas); index.getSettings().put("index.refresh_interval", "-1"); NewIndex.NewIndexType type = index.createType(INDEX_TYPE_FAKE.getType()); type.createIntegerField(INT_FIELD); }
public NewIndex create(String key, NewIndex.SettingsConfiguration settingsConfiguration) { Preconditions.checkArgument(!byKey.containsKey(key), String.format("Index already exists: %s", key)); NewIndex index = new NewIndex(key, settingsConfiguration); byKey.put(key, index); return index; }
@Override public void define(IndexDefinitionContext context) { NewIndex index = context.create(indexName, newBuilder(new MapSettings().asConfig()).build()); index.getSettings().put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0); index.getSettings().put("index.refresh_interval", "-1"); } }
@Test public void of() { IndexDefinition.Index indexV1 = new IndexDefinition.Index(createIndex()); String hashV1 = IndexDefinitionHash.of(indexV1); assertThat(hashV1).isNotEmpty(); // always the same assertThat(hashV1).isEqualTo(IndexDefinitionHash.of(indexV1)); NewIndex newIndexV2 = createIndex(); newIndexV2.getTypes().get("fake").createIntegerField("max"); String hashV2 = IndexDefinitionHash.of(new IndexDefinition.Index(newIndexV2)); assertThat(hashV2).isNotEmpty().isNotEqualTo(hashV1); }
NewIndex(String indexName, SettingsConfiguration settingsConfiguration) { checkArgument(StringUtils.isAllLowerCase(indexName), "Index name must be lower-case: " + indexName); this.indexName = indexName; applySettingsConfiguration(settingsConfiguration); }
private void applySettingsConfiguration(SettingsConfiguration settingsConfiguration) { settings.put("index.mapper.dynamic", valueOf(false)); settings.put("index.refresh_interval", refreshInterval(settingsConfiguration)); Configuration config = settingsConfiguration.getConfiguration(); boolean clusterMode = config.getBoolean(CLUSTER_ENABLED.getKey()).orElse(false); int shards = config.getInt(format("sonar.search.%s.shards", indexName)) .orElse(settingsConfiguration.getDefaultNbOfShards()); int replicas = clusterMode ? config.getInt(SEARCH_REPLICAS.getKey()).orElse(1) : 0; settings.put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, shards); settings.put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, replicas); }
@Test public void mark_all_non_existing_index_types_as_uninitialized() { startNewCreator(context -> { NewIndex i = context.create("fakes", SETTINGS_CONFIGURATION); i.createType("t1"); i.createType("t2"); }); assertThat(metadataIndex.getHash("fakes")).isNotEmpty(); assertThat(metadataIndex.getInitialized(new IndexType("fakes", "t1"))).isFalse(); assertThat(metadataIndex.getInitialized(new IndexType("fakes", "t2"))).isFalse(); }
@Test public void define_nested_field() { NewIndex index = new NewIndex("projectmeasures", defaultSettingsConfiguration); NewIndex.NewIndexType mapping = index.createType("projectmeasures"); mapping.nestedFieldBuilder("measures") .addKeywordField("key") .addDoubleField("value") .build(); Map<String, Object> result = (Map) mapping.getProperty("measures"); assertThat(result.get("type")).isEqualTo("nested"); Map<String, Map<String, Object>> subProperties = (Map) result.get("properties"); assertThat(subProperties.get("key").get("type")).isEqualTo("keyword"); assertThat(subProperties.get("value").get("type")).isEqualTo("double"); }
@Test public void define() { ViewIndexDefinition def = new ViewIndexDefinition(new MapSettings().asConfig()); def.define(underTest); assertThat(underTest.getIndices()).hasSize(1); NewIndex index = underTest.getIndices().get("views"); assertThat(index).isNotNull(); assertThat(index.getTypes().keySet()).containsOnly("view"); assertThat(index.getSettings().get("index.number_of_shards")).isEqualTo("5"); assertThat(index.getSettings().get("index.number_of_replicas")).isEqualTo("0"); } }
@Test public void index_name_is_lower_case() { try { new NewIndex("Issues", defaultSettingsConfiguration); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Index name must be lower-case: Issues"); } }
@Test public void enable_replica_if_clustering_is_enabled() { settings.setProperty(CLUSTER_ENABLED.getKey(), true); IndexDefinition.IndexDefinitionContext context = new IndexDefinition.IndexDefinitionContext(); underTest.define(context); NewIndex ruleIndex = context.getIndices().get("rules"); assertThat(ruleIndex.getSettings().get("index.number_of_replicas")).isEqualTo("1"); }
NewIndex(String indexName, SettingsConfiguration settingsConfiguration) { checkArgument(StringUtils.isAllLowerCase(indexName), "Index name must be lower-case: " + indexName); this.indexName = indexName; applySettingsConfiguration(settingsConfiguration); }