Examples with ImmutableOpenMap org.elasticsearch.common.collect.ImmutableOpenMap used on opensource projects

Example 26 with ImmutableOpenMap

use of org.elasticsearch.common.collect.ImmutableOpenMap in project elasticsearch by elastic.

the class RestGetIndicesAction method prepareRequest.

@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    String[] featureParams = request.paramAsStringArray("type", null);
    // Work out if the indices is a list of features
    if (featureParams == null && indices.length > 0 && indices[0] != null && indices[0].startsWith("_") && !"_all".equals(indices[0])) {
        featureParams = indices;
        indices = new String[] { "_all" };
    }
    final GetIndexRequest getIndexRequest = new GetIndexRequest();
    getIndexRequest.indices(indices);
    if (featureParams != null) {
        Feature[] features = Feature.convertToFeatures(featureParams);
        getIndexRequest.features(features);
    }
    getIndexRequest.indicesOptions(IndicesOptions.fromRequest(request, getIndexRequest.indicesOptions()));
    getIndexRequest.local(request.paramAsBoolean("local", getIndexRequest.local()));
    getIndexRequest.humanReadable(request.paramAsBoolean("human", false));
    final boolean defaults = request.paramAsBoolean("include_defaults", false);
    return channel -> client.admin().indices().getIndex(getIndexRequest, new RestBuilderListener<GetIndexResponse>(channel) {

        @Override
        public RestResponse buildResponse(final GetIndexResponse response, final XContentBuilder builder) throws Exception {
            builder.startObject();
            {
                for (final String index : response.indices()) {
                    builder.startObject(index);
                    {
                        for (final Feature feature : getIndexRequest.features()) {
                            switch(feature) {
                                case ALIASES:
                                    writeAliases(response.aliases().get(index), builder, request);
                                    break;
                                case MAPPINGS:
                                    writeMappings(response.mappings().get(index), builder);
                                    break;
                                case SETTINGS:
                                    writeSettings(response.settings().get(index), builder, request, defaults);
                                    break;
                                default:
                                    throw new IllegalStateException("feature [" + feature + "] is not valid");
                            }
                        }
                    }
                    builder.endObject();
                }
            }
            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }

        private void writeAliases(final List<AliasMetaData> aliases, final XContentBuilder builder, final Params params) throws IOException {
            builder.startObject("aliases");
            {
                if (aliases != null) {
                    for (final AliasMetaData alias : aliases) {
                        AliasMetaData.Builder.toXContent(alias, builder, params);
                    }
                }
            }
            builder.endObject();
        }

        private void writeMappings(final ImmutableOpenMap<String, MappingMetaData> mappings, final XContentBuilder builder) throws IOException {
            builder.startObject("mappings");
            {
                if (mappings != null) {
                    for (final ObjectObjectCursor<String, MappingMetaData> typeEntry : mappings) {
                        builder.field(typeEntry.key);
                        builder.map(typeEntry.value.sourceAsMap());
                    }
                }
            }
            builder.endObject();
        }

        private void writeSettings(final Settings settings, final XContentBuilder builder, final Params params, final boolean defaults) throws IOException {
            builder.startObject("settings");
            {
                settings.toXContent(builder, params);
            }
            builder.endObject();
            if (defaults) {
                builder.startObject("defaults");
                {
                    settingsFilter.filter(indexScopedSettings.diff(settings, RestGetIndicesAction.this.settings)).toXContent(builder, request);
                }
                builder.endObject();
            }
        }
    });
}

Example 27 with ImmutableOpenMap

use of org.elasticsearch.common.collect.ImmutableOpenMap in project elasticsearch by elastic.

the class RestGetMappingAction method prepareRequest.

@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    final String[] types = request.paramAsStringArrayOrEmptyIfAll("type");
    GetMappingsRequest getMappingsRequest = new GetMappingsRequest();
    getMappingsRequest.indices(indices).types(types);
    getMappingsRequest.indicesOptions(IndicesOptions.fromRequest(request, getMappingsRequest.indicesOptions()));
    getMappingsRequest.local(request.paramAsBoolean("local", getMappingsRequest.local()));
    return channel -> client.admin().indices().getMappings(getMappingsRequest, new RestBuilderListener<GetMappingsResponse>(channel) {

        @Override
        public RestResponse buildResponse(GetMappingsResponse response, XContentBuilder builder) throws Exception {
            ImmutableOpenMap<String, ImmutableOpenMap<String, MappingMetaData>> mappingsByIndex = response.getMappings();
            if (mappingsByIndex.isEmpty()) {
                if (indices.length != 0 && types.length != 0) {
                    return new BytesRestResponse(OK, builder.startObject().endObject());
                } else if (indices.length != 0) {
                    builder.close();
                    return new BytesRestResponse(channel, new IndexNotFoundException(indices[0]));
                } else if (types.length != 0) {
                    builder.close();
                    return new BytesRestResponse(channel, new TypeMissingException("_all", types[0]));
                } else {
                    return new BytesRestResponse(OK, builder.startObject().endObject());
                }
            }
            builder.startObject();
            for (ObjectObjectCursor<String, ImmutableOpenMap<String, MappingMetaData>> indexEntry : mappingsByIndex) {
                if (indexEntry.value.isEmpty()) {
                    continue;
                }
                builder.startObject(indexEntry.key);
                builder.startObject(Fields.MAPPINGS);
                for (ObjectObjectCursor<String, MappingMetaData> typeEntry : indexEntry.value) {
                    builder.field(typeEntry.key);
                    builder.map(typeEntry.value.sourceAsMap());
                }
                builder.endObject();
                builder.endObject();
            }
            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }
    });
}

Example 28 with ImmutableOpenMap

use of org.elasticsearch.common.collect.ImmutableOpenMap in project elasticsearch by elastic.

the class Engine method getSegmentFileSizes.

private ImmutableOpenMap<String, Long> getSegmentFileSizes(SegmentReader segmentReader) {
    Directory directory = null;
    SegmentCommitInfo segmentCommitInfo = segmentReader.getSegmentInfo();
    boolean useCompoundFile = segmentCommitInfo.info.getUseCompoundFile();
    if (useCompoundFile) {
        try {
            directory = engineConfig.getCodec().compoundFormat().getCompoundReader(segmentReader.directory(), segmentCommitInfo.info, IOContext.READ);
        } catch (IOException e) {
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Error when opening compound reader for Directory [{}] and SegmentCommitInfo [{}]", segmentReader.directory(), segmentCommitInfo), e);
            return ImmutableOpenMap.of();
        }
    } else {
        directory = segmentReader.directory();
    }
    assert directory != null;
    String[] files;
    if (useCompoundFile) {
        try {
            files = directory.listAll();
        } catch (IOException e) {
            final Directory finalDirectory = directory;
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Couldn't list Compound Reader Directory [{}]", finalDirectory), e);
            return ImmutableOpenMap.of();
        }
    } else {
        try {
            files = segmentReader.getSegmentInfo().files().toArray(new String[] {});
        } catch (IOException e) {
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Couldn't list Directory from SegmentReader [{}] and SegmentInfo [{}]", segmentReader, segmentReader.getSegmentInfo()), e);
            return ImmutableOpenMap.of();
        }
    }
    ImmutableOpenMap.Builder<String, Long> map = ImmutableOpenMap.builder();
    for (String file : files) {
        String extension = IndexFileNames.getExtension(file);
        long length = 0L;
        try {
            length = directory.fileLength(file);
        } catch (NoSuchFileException | FileNotFoundException e) {
            final Directory finalDirectory = directory;
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Tried to query fileLength but file is gone [{}] [{}]", finalDirectory, file), e);
        } catch (IOException e) {
            final Directory finalDirectory = directory;
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Error when trying to query fileLength [{}] [{}]", finalDirectory, file), e);
        }
        if (length == 0L) {
            continue;
        }
        map.put(extension, length);
    }
    if (useCompoundFile && directory != null) {
        try {
            directory.close();
        } catch (IOException e) {
            final Directory finalDirectory = directory;
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Error when closing compound reader on Directory [{}]", finalDirectory), e);
        }
    }
    return map.build();
}

Example 29 with ImmutableOpenMap

use of org.elasticsearch.common.collect.ImmutableOpenMap in project elasticsearch by elastic.

the class GetIndexIT method assertEmptyOrOnlyDefaultMappings.

private void assertEmptyOrOnlyDefaultMappings(GetIndexResponse response, String indexName) {
    ImmutableOpenMap<String, ImmutableOpenMap<String, MappingMetaData>> mappings = response.mappings();
    assertThat(mappings, notNullValue());
    assertThat(mappings.size(), equalTo(1));
    ImmutableOpenMap<String, MappingMetaData> indexMappings = mappings.get(indexName);
    assertThat(indexMappings, notNullValue());
    assertThat(indexMappings.size(), anyOf(equalTo(0), equalTo(1)));
    if (indexMappings.size() == 1) {
        MappingMetaData mapping = indexMappings.get("_default_");
        assertThat(mapping, notNullValue());
    }
}

Example 30 with ImmutableOpenMap

use of org.elasticsearch.common.collect.ImmutableOpenMap in project elasticsearch by elastic.

the class ESIntegTestCase method assertMappingOnMaster.

/**
     * Waits for the given mapping type to exists on the master node.
     */
public void assertMappingOnMaster(final String index, final String type, final String... fieldNames) throws Exception {
    GetMappingsResponse response = client().admin().indices().prepareGetMappings(index).setTypes(type).get();
    ImmutableOpenMap<String, MappingMetaData> mappings = response.getMappings().get(index);
    assertThat(mappings, notNullValue());
    MappingMetaData mappingMetaData = mappings.get(type);
    assertThat(mappingMetaData, notNullValue());
    Map<String, Object> mappingSource = mappingMetaData.getSourceAsMap();
    assertFalse(mappingSource.isEmpty());
    assertTrue(mappingSource.containsKey("properties"));
    for (String fieldName : fieldNames) {
        Map<String, Object> mappingProperties = (Map<String, Object>) mappingSource.get("properties");
        if (fieldName.indexOf('.') != -1) {
            fieldName = fieldName.replace(".", ".properties.");
        }
        assertThat("field " + fieldName + " doesn't exists in mapping " + mappingMetaData.source().string(), XContentMapValues.extractValue(fieldName, mappingProperties), notNullValue());
    }
}