Java IndexTemplateMetaData类代码示例

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
/**
 * Removes all templates, except the templates defined in the exclude
 */
public void wipeAllTemplates(Set<String> exclude) {
    if (size() > 0) {
        GetIndexTemplatesResponse response = client().admin().indices().prepareGetTemplates().get();
        for (IndexTemplateMetaData indexTemplate : response.getIndexTemplates()) {
            if (exclude.contains(indexTemplate.getName())) {
                continue;
            }
            try {
                client().admin().indices().prepareDeleteTemplate(indexTemplate.getName()).execute().actionGet();
            } catch (IndexTemplateMissingException e) {
                // ignore
            }
        }
    }
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
private Table buildTable(RestRequest request, ClusterStateResponse clusterStateResponse, String patternString) {
    Table table = getTableWithHeader(request);
    MetaData metadata = clusterStateResponse.getState().metaData();
    for (ObjectObjectCursor<String, IndexTemplateMetaData> entry : metadata.templates()) {
        IndexTemplateMetaData indexData = entry.value;
        if (patternString == null || Regex.simpleMatch(patternString, indexData.name())) {
            table.startRow();
            table.addCell(indexData.name());
            table.addCell("[" + String.join(", ", indexData.patterns()) + "]");
            table.addCell(indexData.getOrder());
            table.addCell(indexData.getVersion());
            table.endRow();
        }
    }
    return table;
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
@Override
protected void masterOperation(GetIndexTemplatesRequest request, ClusterState state, ActionListener<GetIndexTemplatesResponse> listener) {
    List<IndexTemplateMetaData> results;

    // If we did not ask for a specific name, then we return all templates
    if (request.names().length == 0) {
        results = Arrays.asList(state.metaData().templates().values().toArray(IndexTemplateMetaData.class));
    } else {
        results = new ArrayList<>();
    }

    for (String name : request.names()) {
        if (Regex.isSimpleMatchPattern(name)) {
            for (ObjectObjectCursor<String, IndexTemplateMetaData> entry : state.metaData().templates()) {
                if (Regex.simpleMatch(name, entry.key)) {
                    results.add(entry.value);
                }
            }
        } else if (state.metaData().templates().containsKey(name)) {
            results.add(state.metaData().templates().get(name));
        }
    }

    listener.onResponse(new GetIndexTemplatesResponse(results));
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
public void testClusterStateSerialization() throws Exception {
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test_idx").settings(settings(Version.CURRENT)).numberOfShards(10).numberOfReplicas(1))
            .put(IndexTemplateMetaData.builder("test_template").build())
            .build();

    RoutingTable routingTable = RoutingTable.builder()
            .addAsNew(metaData.index("test_idx"))
            .build();

    DiscoveryNodes nodes = DiscoveryNodes.builder().add(new DiscoveryNode("node_foo", buildNewFakeTransportAddress(),
            emptyMap(), emptySet(), Version.CURRENT)).localNodeId("node_foo").masterNodeId("node_foo").build();

    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).nodes(nodes)
        .metaData(metaData).routingTable(routingTable).build();

    AllocationService strategy = createAllocationService();
    clusterState = ClusterState.builder(clusterState).routingTable(strategy.reroute(clusterState, "reroute").routingTable()).build();

    String clusterStateString = Strings.toString(clusterState);
    assertNotNull(clusterStateString);

    assertThat(clusterStateString, containsString("test_idx"));
    assertThat(clusterStateString, containsString("test_template"));
    assertThat(clusterStateString, containsString("node_foo"));
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
private Map<String, Object> mergeTemplateMapping(IndexTemplateMetaData templateMetaData,
                                                 Map<String, Object> newMapping) {
    Map<String, Object> mergedMapping = new HashMap<>();
    for (ObjectObjectCursor<String, CompressedXContent> cursor : templateMetaData.mappings()) {
        try {
            Map<String, Object> mapping = parseMapping(cursor.value.toString());
            Object o = mapping.get(Constants.DEFAULT_MAPPING_TYPE);
            assert o != null && o instanceof Map;

            XContentHelper.update(mergedMapping, (Map) o, false);
        } catch (IOException e) {
            // pass
        }
    }
    XContentHelper.update(mergedMapping, newMapping, false);
    return mergedMapping;
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
/**
 * Assert that an index template is missing
 */
public static void assertIndexTemplateMissing(GetIndexTemplatesResponse templatesResponse, String name) {
    List<String> templateNames = new ArrayList<>();
    for (IndexTemplateMetaData indexTemplateMetaData : templatesResponse.getIndexTemplates()) {
        templateNames.add(indexTemplateMetaData.name());
    }
    assertThat(templateNames, not(hasItem(name)));
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
/**
 * Assert that an index template exists
 */
public static void assertIndexTemplateExists(GetIndexTemplatesResponse templatesResponse, String name) {
    List<String> templateNames = new ArrayList<>();
    for (IndexTemplateMetaData indexTemplateMetaData : templatesResponse.getIndexTemplates()) {
        templateNames.add(indexTemplateMetaData.name());
    }
    assertThat(templateNames, hasItem(name));
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    super.readFrom(in);
    int size = in.readVInt();
    indexTemplates = new ArrayList<>(size);
    for (int i = 0 ; i < size ; i++) {
        indexTemplates.add(0, IndexTemplateMetaData.readFrom(in));
    }
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeVInt(indexTemplates.size());
    for (IndexTemplateMetaData indexTemplate : indexTemplates) {
        indexTemplate.writeTo(out);
    }
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    params = new ToXContent.DelegatingMapParams(singletonMap("reduce_mappings", "true"), params);
    builder.startObject();
    for (IndexTemplateMetaData indexTemplateMetaData : getIndexTemplates()) {
        IndexTemplateMetaData.Builder.toXContent(indexTemplateMetaData, builder, params);
    }
    builder.endObject();
    return builder;
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
private ListenableFuture<Long> updateTemplate(Map<String, Object> newMappings,
                                              Settings newSettings,
                                              TableIdent tableIdent,
                                              AbstractDDLAnalyzedStatement statement) {
    String templateName = PartitionName.templateName(tableIdent.schema(), tableIdent.name());
    IndexTemplateMetaData indexTemplateMetaData =
            clusterService.state().metaData().templates().get(templateName);
    if (indexTemplateMetaData == null) {
        return Futures.immediateFailedFuture(new RuntimeException("Template for partitioned table is missing"));
    }

    // merge mappings
    Map<String, Object> mapping = mergeTemplateMapping(indexTemplateMetaData, newMappings);

    // merge settings
    Settings.Builder settingsBuilder = Settings.builder();
    settingsBuilder.put(indexTemplateMetaData.settings());
    settingsBuilder.put(newSettings);

    PutIndexTemplateRequest request = new PutIndexTemplateRequest(templateName)
            .create(false)
            .mapping(Constants.DEFAULT_MAPPING_TYPE, mapping)
            .order(indexTemplateMetaData.order())
            .settings(settingsBuilder.build())
            .template(indexTemplateMetaData.template());

    request.putHeader(LoginUserContext.USER_INFO_KEY, statement.getParameterContext().getLoginUserContext());
    for (ObjectObjectCursor<String, AliasMetaData> container : indexTemplateMetaData.aliases()) {
        Alias alias = new Alias(container.key);
        request.alias(alias);
    }

    SettableFuture<Long> result = SettableFuture.create();
    transportActionProvider.transportPutIndexTemplateAction().execute(request,
            new SettableFutureToNullActionListener<PutIndexTemplateResponse>(result));

    return result;
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
    final String[] names = Strings.splitStringByCommaToArray(request.param("name"));

    GetIndexTemplatesRequest getIndexTemplatesRequest = new GetIndexTemplatesRequest(names);
    getIndexTemplatesRequest.local(request.paramAsBoolean("local", getIndexTemplatesRequest.local()));
    getIndexTemplatesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", getIndexTemplatesRequest.masterNodeTimeout()));

    final boolean implicitAll = getIndexTemplatesRequest.names().length == 0;

    client.admin().indices().getTemplates(getIndexTemplatesRequest, new RestBuilderListener<GetIndexTemplatesResponse>(channel) {
        @Override
        public RestResponse buildResponse(GetIndexTemplatesResponse getIndexTemplatesResponse, XContentBuilder builder) throws Exception {
            boolean templateExists = getIndexTemplatesResponse.getIndexTemplates().size() > 0;

            Map<String, String> paramsMap = Maps.newHashMap();
            paramsMap.put("reduce_mappings", "true");
            ToXContent.Params params = new ToXContent.DelegatingMapParams(paramsMap, request);

            builder.startObject();
            for (IndexTemplateMetaData indexTemplateMetaData : getIndexTemplatesResponse.getIndexTemplates()) {
                IndexTemplateMetaData.Builder.toXContent(indexTemplateMetaData, builder, params);
            }
            builder.endObject();

            RestStatus restStatus = (templateExists || implicitAll) ? OK : NOT_FOUND;

            return new BytesRestResponse(restStatus, builder);
        }
    });
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    super.readFrom(in);
    int size = in.readVInt();
    indexTemplates = new ArrayList<>(size);
    for (int i = 0 ; i < size ; i++) {
        indexTemplates.add(0, IndexTemplateMetaData.Builder.readFrom(in));
    }
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
@Test
public void testThatTemplateIsAdded() throws Exception {
    GetIndexTemplatesResponse response = client().admin().indices().prepareGetTemplates("metrics_template").get();

    assertThat(response.getIndexTemplates(), hasSize(1));
    IndexTemplateMetaData templateData = response.getIndexTemplates().get(0);
    assertThat(templateData.order(), is(0));
    assertThat(templateData.getMappings().get("_default_"), is(notNullValue()));
}
 

import org.elasticsearch.cluster.metadata.IndexTemplateMetaData; //导入依赖的package包/类
@Test
public void testThatTemplateIsNotOverWritten() throws Exception {
    client().admin().indices().preparePutTemplate("metrics_template").setTemplate("foo*").setSettings("{ \"index.number_of_shards\" : \"1\"}").execute().actionGet();

    elasticsearchReporter = createElasticsearchReporterBuilder().build();

    GetIndexTemplatesResponse response = client().admin().indices().prepareGetTemplates("metrics_template").get();

    assertThat(response.getIndexTemplates(), hasSize(1));
    IndexTemplateMetaData templateData = response.getIndexTemplates().get(0);
    assertThat(templateData.template(), is("foo*"));
}