Java IndicesAliasesRequestBuilder.removeAlias方法代码示例

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder; //导入方法依赖的package包/类
/**
 * Activates an index by moving the alias from the old index to the new one.
 */
@Override
public void activateIndex(String indexName, String aliasName) {
    Map<String, Set<String>> indexAliasMap = getIndexAliases();

    IndicesAliasesRequestBuilder builder = indicesAdminClient().prepareAliases();

    if (indexAliasMap.size() > 0) {
        Set<String> aliasNames = indexAliasMap.keySet();

        for (String an : aliasNames) {
            Set<String> indexNames = indexAliasMap.get(an);

            for (String in : indexNames) {
                if (an.equals(aliasName)) {
                    log.info("Removing alias '" + an + "' from index '" + in + "'.");

                    builder.removeAlias(in, an);
                }
            }
        }
    }

    IndicesAliasesResponse response = builder.addAlias(indexName, aliasName).execute().actionGet();

    log.info("activateIndex: [indexName=" + indexName + ", aliasName=" + aliasName + ", isAcknowledged="
        + response.isAcknowledged() + "].");
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder; //导入方法依赖的package包/类
/**
 * Makes one alias point to another's index, deleting the old index afterwards. Returns true
 * iff the operation was successful.
 */
private synchronized boolean redirectAndDeleteAliasedIndex(String fromAlias, String toAlias) {
    // Find indices corresponding to aliases
    String fromIndex = getIndexFromAlias(fromAlias);
    String toIndex = getIndexFromAlias(toAlias);

    if (toIndex == null) {
        log.error("{} does not resolve to an index", toAlias);
        return false;
    }

    if (toIndex.equals(fromIndex)) {
        log.warn("{} and {} resolve to the same index", fromAlias, toAlias);
        return false;
    }

    // Perform alias switch
    IndicesAliasesRequestBuilder builder = es.getClient().admin().indices().prepareAliases();
    if (fromIndex != null) {
        builder.removeAlias(fromIndex, fromAlias);
    }
    builder.addAlias(toIndex, fromAlias).get();

    // Delete old index
    if (fromIndex != null) {
        es.getClient().admin().indices().prepareDelete(fromIndex).get();
    }

    return true;
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder; //导入方法依赖的package包/类
private void addAlias(String indexName) {
    Timer.Context timer = updateAliasTimer.time();
    try {
        Boolean isAck;

        final AdminClient adminClient = esProvider.getClient().admin();

        String[] indexNames = getIndexes(AliasType.Write);

        int count = 0;
        IndicesAliasesRequestBuilder aliasesRequestBuilder = adminClient.indices().prepareAliases();
        for (String currentIndex : indexNames) {
            aliasesRequestBuilder.removeAlias(currentIndex, alias.getWriteAlias());
            count++;
        }
        if (count > 0) {
            isAck = aliasesRequestBuilder.execute().actionGet().isAcknowledged();
            logger.info("Removed Index Name from Alias=[{}] ACK=[{}]", alias, isAck);
        }
        aliasesRequestBuilder = adminClient.indices().prepareAliases();
        //Added For Graphite Metrics
        //add write alias
        aliasesRequestBuilder.addAlias(indexName, alias.getWriteAlias());
        //Added For Graphite Metrics
        // add read alias
        aliasesRequestBuilder.addAlias(indexName, alias.getReadAlias());

        isAck = aliasesRequestBuilder.execute().actionGet().isAcknowledged();
        logger.info("Created new read and write aliases ACK=[{}]", isAck);
        aliasCache.invalidate(alias);

    } catch (Exception e) {
        logger.warn("Failed to create alias ", e);
    } finally {
        timer.stop();
    }
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder; //导入方法依赖的package包/类
public void createNextIndex() {
    try {
        final List<String> prevIndices = new ArrayList<>();
        final IndicesExistsResponse response =
                client.admin().indices().prepareExists(getUpdateAlias(index)).execute().actionGet(suggestSettings.getIndicesTimeout());
        if (response.isExists()) {
            GetAliasesResponse getAliasesResponse =
                    client.admin().indices().prepareGetAliases(getUpdateAlias(index)).execute().actionGet();
            getAliasesResponse.getAliases().keysIt().forEachRemaining(prevIndices::add);
        }

        final String mappingSource = getDefaultMappings();
        final String settingsSource = getDefaultIndexSettings();
        final String indexName = createIndexName(index);
        CreateIndexResponse createIndexResponse =
                client.admin().indices().prepareCreate(indexName).setSettings(settingsSource.toString(), XContentType.JSON)
                        .addMapping(type, mappingSource, XContentType.JSON).execute().actionGet(suggestSettings.getIndicesTimeout());
        if (!createIndexResponse.isAcknowledged()) {
            throw new SuggesterException("Failed to create index");
        }
        client.admin().cluster().prepareHealth().setWaitForYellowStatus().execute().actionGet(suggestSettings.getClusterTimeout());

        final IndicesAliasesRequestBuilder aliasesRequestBuilder =
                client.admin().indices().prepareAliases().addAlias(indexName, getUpdateAlias(index));
        for (final String prevIndex : prevIndices) {
            aliasesRequestBuilder.removeAlias(prevIndex, getUpdateAlias(index));
        }
        aliasesRequestBuilder.execute().actionGet();
    } catch (final Exception e) {
        throw new SuggesterException("Failed to create index.", e);
    }
}