Java IndicesAliasesRequest.AliasActions方法代码示例

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入方法依赖的package包/类
private void aliasActionToJson(IndicesAliasesRequest.AliasActions actions, String alias, String index, XContentBuilder builder) throws IOException {
    String filter = actions.aliasAction().filter();
    String indexRouting = actions.aliasAction().indexRouting();
    String searchRouting = actions.aliasAction().searchRouting();
    AliasAction.Type type = actions.aliasAction().actionType();

    builder.startObject();
    builder.startObject(type.name().toLowerCase());
    if (alias != null) {
        builder.field("alias", alias);
    }
    if (index != null) {
        builder.field("index", index);
    }
    if (filter != null) {
        builder.rawField("filter", filter.getBytes());
    }
    if (searchRouting != null) {
        builder.field("search_routing", searchRouting);
    }
    if (indexRouting != null) {
        builder.field("index_routing", indexRouting);
    }
    builder.endObject();
    builder.endObject();
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入方法依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    String alias = request.param("name");
    Map<String, Object> filter = null;
    String routing = null;
    String indexRouting = null;
    String searchRouting = null;

    if (request.hasContent()) {
        try (XContentParser parser = request.contentParser()) {
            XContentParser.Token token = parser.nextToken();
            if (token == null) {
                throw new IllegalArgumentException("No index alias is specified");
            }
            String currentFieldName = null;
            while ((token = parser.nextToken()) != null) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token.isValue()) {
                    if ("index".equals(currentFieldName)) {
                        indices = Strings.splitStringByCommaToArray(parser.text());
                    } else if ("alias".equals(currentFieldName)) {
                        alias = parser.text();
                    } else if ("routing".equals(currentFieldName)) {
                        routing = parser.textOrNull();
                    } else if ("indexRouting".equals(currentFieldName)
                            || "index-routing".equals(currentFieldName) || "index_routing".equals(currentFieldName)) {
                        indexRouting = parser.textOrNull();
                    } else if ("searchRouting".equals(currentFieldName)
                            || "search-routing".equals(currentFieldName) || "search_routing".equals(currentFieldName)) {
                        searchRouting = parser.textOrNull();
                    }
                } else if (token == XContentParser.Token.START_OBJECT) {
                    if ("filter".equals(currentFieldName)) {
                        filter = parser.mapOrdered();
                    }
                }
            }
        }
    }

    IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
    indicesAliasesRequest.timeout(request.paramAsTime("timeout", indicesAliasesRequest.timeout()));
    indicesAliasesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", indicesAliasesRequest.masterNodeTimeout()));

    IndicesAliasesRequest.AliasActions aliasAction = AliasActions.add().indices(indices).alias(alias);
    if (routing != null) {
        aliasAction.routing(routing);
    }
    if (searchRouting != null) {
        aliasAction.searchRouting(searchRouting);
    }
    if (indexRouting != null) {
        aliasAction.indexRouting(indexRouting);
    }
    if (filter != null) {
        aliasAction.filter(filter);
    }
    indicesAliasesRequest.addAliasAction(aliasAction);
    return channel -> client.admin().indices().aliases(indicesAliasesRequest, new AcknowledgedRestListener<>(channel));
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入方法依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) throws Exception {
    String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    String alias = request.param("name");
    Map<String, Object> filter = null;
    String routing = null;
    String indexRouting = null;
    String searchRouting = null;

    if (request.hasContent()) {
        try (XContentParser parser = XContentFactory.xContent(request.content()).createParser(request.content())) {
            XContentParser.Token token = parser.nextToken();
            if (token == null) {
                throw new IllegalArgumentException("No index alias is specified");
            }
            String currentFieldName = null;
            while ((token = parser.nextToken()) != null) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token.isValue()) {
                    if ("index".equals(currentFieldName)) {
                        indices = Strings.splitStringByCommaToArray(parser.text());
                    } else if ("alias".equals(currentFieldName)) {
                        alias = parser.text();
                    } else if ("routing".equals(currentFieldName)) {
                        routing = parser.textOrNull();
                    } else if ("indexRouting".equals(currentFieldName) || "index-routing".equals(currentFieldName) || "index_routing".equals(currentFieldName)) {
                        indexRouting = parser.textOrNull();
                    } else if ("searchRouting".equals(currentFieldName) || "search-routing".equals(currentFieldName) || "search_routing".equals(currentFieldName)) {
                        searchRouting = parser.textOrNull();
                    }
                } else if (token == XContentParser.Token.START_OBJECT) {
                    if ("filter".equals(currentFieldName)) {
                        filter = parser.mapOrdered();
                    }
                }
            }
        }
    }

    IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
    indicesAliasesRequest.timeout(request.paramAsTime("timeout", indicesAliasesRequest.timeout()));
    String[] aliases = new String[]{alias};
    IndicesAliasesRequest.AliasActions aliasAction = new AliasActions(AliasAction.Type.ADD, indices, aliases);
    indicesAliasesRequest.addAliasAction(aliasAction);
    indicesAliasesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", indicesAliasesRequest.masterNodeTimeout()));


    if (routing != null) {
        aliasAction.routing(routing);
    }
    if (searchRouting != null) {
        aliasAction.searchRouting(searchRouting);
    }
    if (indexRouting != null) {
        aliasAction.indexRouting(indexRouting);
    }
    if (filter != null) {
        aliasAction.filter(filter);
    }
    client.admin().indices().aliases(indicesAliasesRequest, new AcknowledgedRestListener<IndicesAliasesResponse>(channel));
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入方法依赖的package包/类
public void execute(IndicesAliasesRequest request, final ActionListener<IndicesAliasesResponse> listener) {
    logger.debug("indices aliases request {}", request);
    try {
        RequestUriBuilder uriBuilder = new RequestUriBuilder().addEndpoint("_aliases");

        XContentBuilder jsonBuilder = XContentFactory.jsonBuilder().startObject();
        jsonBuilder.startArray("actions");

        List<IndicesAliasesRequest.AliasActions> actions = request.getAliasActions();
        for (IndicesAliasesRequest.AliasActions action : actions) {
            for (String alias : action.aliases()) {
                for (String index : action.indices()) {
                    aliasActionToJson(action, alias, index, jsonBuilder);
                }
            }
        }
        jsonBuilder.endArray();
        jsonBuilder.endObject();

        uriBuilder.addQueryParameter("timeout", request.timeout().toString());
        uriBuilder.addQueryParameter("master_timeout", request.masterNodeTimeout().toString());

        uriBuilder.addIndicesOptions(request.indicesOptions());

        byte[] body = jsonBuilder.bytes().toBytes();

        indicesAdminClient.getHttpClient().submit(HttpClientRequest.createPost(uriBuilder.toString())
                .withContent(body))
                .flatMap(ErrorHandler.AS_FUNC)
                .flatMap(new Func1<HttpClientResponse<ByteBuf>, Observable<IndicesAliasesResponse>>() {
                    @Override
                    public Observable<IndicesAliasesResponse> call(final HttpClientResponse<ByteBuf> response) {
                        return response.getContent().flatMap(new Func1<ByteBuf, Observable<IndicesAliasesResponse>>() {
                            @Override
                            public Observable<IndicesAliasesResponse> call(ByteBuf byteBuf) {
                                return IndicesAliasesResponse.parse(byteBuf, response.getStatus().code());
                            }
                        });
                    }
                })
                .single()
                .subscribe(new ListenerCompleterObserver<>(listener));

    } catch (Exception e) {
        listener.onFailure(e);
    }
}