OpenSearch/src/main/java/org/elasticsearch/client/node/NodeIndicesAdminClient.java

/*
 * Licensed to ElasticSearch and Shay Banon under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. ElasticSearch licenses this
 * file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.elasticsearch.client.node;

import org.elasticsearch.action.ActionFuture;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesResponse;
import org.elasticsearch.action.admin.indices.alias.TransportIndicesAliasesAction;
import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest;
import org.elasticsearch.action.admin.indices.analyze.AnalyzeResponse;
import org.elasticsearch.action.admin.indices.analyze.TransportAnalyzeAction;
import org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest;
import org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheResponse;
import org.elasticsearch.action.admin.indices.cache.clear.TransportClearIndicesCacheAction;
import org.elasticsearch.action.admin.indices.close.CloseIndexRequest;
import org.elasticsearch.action.admin.indices.close.CloseIndexResponse;
import org.elasticsearch.action.admin.indices.close.TransportCloseIndexAction;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.create.TransportCreateIndexAction;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
import org.elasticsearch.action.admin.indices.delete.TransportDeleteIndexAction;
import org.elasticsearch.action.admin.indices.exists.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.exists.IndicesExistsResponse;
import org.elasticsearch.action.admin.indices.exists.TransportIndicesExistsAction;
import org.elasticsearch.action.admin.indices.flush.FlushRequest;
import org.elasticsearch.action.admin.indices.flush.FlushResponse;
import org.elasticsearch.action.admin.indices.flush.TransportFlushAction;
import org.elasticsearch.action.admin.indices.gateway.snapshot.GatewaySnapshotRequest;
import org.elasticsearch.action.admin.indices.gateway.snapshot.GatewaySnapshotResponse;
import org.elasticsearch.action.admin.indices.gateway.snapshot.TransportGatewaySnapshotAction;
import org.elasticsearch.action.admin.indices.mapping.delete.DeleteMappingRequest;
import org.elasticsearch.action.admin.indices.mapping.delete.DeleteMappingResponse;
import org.elasticsearch.action.admin.indices.mapping.delete.TransportDeleteMappingAction;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingResponse;
import org.elasticsearch.action.admin.indices.mapping.put.TransportPutMappingAction;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexResponse;
import org.elasticsearch.action.admin.indices.open.TransportOpenIndexAction;
import org.elasticsearch.action.admin.indices.optimize.OptimizeRequest;
import org.elasticsearch.action.admin.indices.optimize.OptimizeResponse;
import org.elasticsearch.action.admin.indices.optimize.TransportOptimizeAction;
import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
import org.elasticsearch.action.admin.indices.refresh.RefreshResponse;
import org.elasticsearch.action.admin.indices.refresh.TransportRefreshAction;
import org.elasticsearch.action.admin.indices.segments.IndicesSegmentResponse;
import org.elasticsearch.action.admin.indices.segments.IndicesSegmentsRequest;
import org.elasticsearch.action.admin.indices.segments.TransportIndicesSegmentsAction;
import org.elasticsearch.action.admin.indices.settings.TransportUpdateSettingsAction;
import org.elasticsearch.action.admin.indices.settings.UpdateSettingsRequest;
import org.elasticsearch.action.admin.indices.settings.UpdateSettingsResponse;
import org.elasticsearch.action.admin.indices.stats.IndicesStats;
import org.elasticsearch.action.admin.indices.stats.IndicesStatsRequest;
import org.elasticsearch.action.admin.indices.stats.TransportIndicesStatsAction;
import org.elasticsearch.action.admin.indices.status.IndicesStatusRequest;
import org.elasticsearch.action.admin.indices.status.IndicesStatusResponse;
import org.elasticsearch.action.admin.indices.status.TransportIndicesStatusAction;
import org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest;
import org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateResponse;
import org.elasticsearch.action.admin.indices.template.delete.TransportDeleteIndexTemplateAction;
import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest;
import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateResponse;
import org.elasticsearch.action.admin.indices.template.put.TransportPutIndexTemplateAction;
import org.elasticsearch.action.admin.indices.validate.query.TransportValidateQueryAction;
import org.elasticsearch.action.admin.indices.validate.query.ValidateQueryRequest;
import org.elasticsearch.action.admin.indices.validate.query.ValidateQueryResponse;
import org.elasticsearch.client.IndicesAdminClient;
import org.elasticsearch.client.support.AbstractIndicesAdminClient;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.threadpool.ThreadPool;

/**
 *
 */
public class NodeIndicesAdminClient extends AbstractIndicesAdminClient implements IndicesAdminClient {

    private final ThreadPool threadPool;

    private final TransportIndicesExistsAction indicesExistsAction;

    private final TransportIndicesStatsAction indicesStatsAction;

    private final TransportIndicesStatusAction indicesStatusAction;

    private final TransportIndicesSegmentsAction indicesSegmentsAction;

    private final TransportCreateIndexAction createIndexAction;

    private final TransportDeleteIndexAction deleteIndexAction;

    private final TransportCloseIndexAction closeIndexAction;

    private final TransportOpenIndexAction openIndexAction;

    private final TransportRefreshAction refreshAction;

    private final TransportFlushAction flushAction;

    private final TransportOptimizeAction optimizeAction;

    private final TransportPutMappingAction putMappingAction;

    private final TransportDeleteMappingAction deleteMappingAction;

    private final TransportGatewaySnapshotAction gatewaySnapshotAction;

    private final TransportIndicesAliasesAction indicesAliasesAction;

    private final TransportClearIndicesCacheAction clearIndicesCacheAction;

    private final TransportUpdateSettingsAction updateSettingsAction;

    private final TransportAnalyzeAction analyzeAction;

    private final TransportPutIndexTemplateAction putIndexTemplateAction;

    private final TransportDeleteIndexTemplateAction deleteIndexTemplateAction;

    private final TransportValidateQueryAction validateQueryAction;

    @Inject
    public NodeIndicesAdminClient(Settings settings, ThreadPool threadPool, TransportIndicesExistsAction indicesExistsAction, TransportIndicesStatsAction indicesStatsAction, TransportIndicesStatusAction indicesStatusAction, TransportIndicesSegmentsAction indicesSegmentsAction,
                                  TransportCreateIndexAction createIndexAction, TransportDeleteIndexAction deleteIndexAction,
                                  TransportCloseIndexAction closeIndexAction, TransportOpenIndexAction openIndexAction,
                                  TransportRefreshAction refreshAction, TransportFlushAction flushAction, TransportOptimizeAction optimizeAction,
                                  TransportPutMappingAction putMappingAction, TransportDeleteMappingAction deleteMappingAction, TransportGatewaySnapshotAction gatewaySnapshotAction,
                                  TransportIndicesAliasesAction indicesAliasesAction, TransportClearIndicesCacheAction clearIndicesCacheAction,
                                  TransportUpdateSettingsAction updateSettingsAction, TransportAnalyzeAction analyzeAction,
                                  TransportPutIndexTemplateAction putIndexTemplateAction, TransportDeleteIndexTemplateAction deleteIndexTemplateAction, TransportValidateQueryAction validateQueryAction) {
        this.threadPool = threadPool;
        this.indicesExistsAction = indicesExistsAction;
        this.indicesStatsAction = indicesStatsAction;
        this.indicesStatusAction = indicesStatusAction;
        this.indicesSegmentsAction = indicesSegmentsAction;
        this.createIndexAction = createIndexAction;
        this.deleteIndexAction = deleteIndexAction;
        this.closeIndexAction = closeIndexAction;
        this.openIndexAction = openIndexAction;
        this.refreshAction = refreshAction;
        this.flushAction = flushAction;
        this.optimizeAction = optimizeAction;
        this.deleteMappingAction = deleteMappingAction;
        this.putMappingAction = putMappingAction;
        this.gatewaySnapshotAction = gatewaySnapshotAction;
        this.indicesAliasesAction = indicesAliasesAction;
        this.clearIndicesCacheAction = clearIndicesCacheAction;
        this.updateSettingsAction = updateSettingsAction;
        this.analyzeAction = analyzeAction;
        this.putIndexTemplateAction = putIndexTemplateAction;
        this.deleteIndexTemplateAction = deleteIndexTemplateAction;
        this.validateQueryAction = validateQueryAction;
    }

    @Override
    public ThreadPool threadPool() {
        return this.threadPool;
    }

    @Override
    public ActionFuture<IndicesExistsResponse> exists(IndicesExistsRequest request) {
        return indicesExistsAction.execute(request);
    }

    @Override
    public void exists(IndicesExistsRequest request, ActionListener<IndicesExistsResponse> listener) {
        indicesExistsAction.execute(request, listener);
    }

    @Override
    public ActionFuture<IndicesStats> stats(IndicesStatsRequest request) {
        return indicesStatsAction.execute(request);
    }

    @Override
    public void stats(IndicesStatsRequest request, ActionListener<IndicesStats> lister) {
        indicesStatsAction.execute(request, lister);
    }

    @Override
    public ActionFuture<IndicesStatusResponse> status(IndicesStatusRequest request) {
        return indicesStatusAction.execute(request);
    }

    @Override
    public void status(IndicesStatusRequest request, ActionListener<IndicesStatusResponse> listener) {
        indicesStatusAction.execute(request, listener);
    }

    @Override
    public ActionFuture<IndicesSegmentResponse> segments(IndicesSegmentsRequest request) {
        return indicesSegmentsAction.execute(request);
    }

    @Override
    public void segments(IndicesSegmentsRequest request, ActionListener<IndicesSegmentResponse> listener) {
        indicesSegmentsAction.execute(request, listener);
    }

    @Override
    public ActionFuture<CreateIndexResponse> create(CreateIndexRequest request) {
        return createIndexAction.execute(request);
    }

    @Override
    public void create(CreateIndexRequest request, ActionListener<CreateIndexResponse> listener) {
        createIndexAction.execute(request, listener);
    }

    @Override
    public ActionFuture<DeleteIndexResponse> delete(DeleteIndexRequest request) {
        return deleteIndexAction.execute(request);
    }

    @Override
    public void delete(DeleteIndexRequest request, ActionListener<DeleteIndexResponse> listener) {
        deleteIndexAction.execute(request, listener);
    }

    @Override
    public ActionFuture<CloseIndexResponse> close(CloseIndexRequest request) {
        return closeIndexAction.execute(request);
    }

    @Override
    public void close(CloseIndexRequest request, ActionListener<CloseIndexResponse> listener) {
        closeIndexAction.execute(request, listener);
    }

    @Override
    public ActionFuture<OpenIndexResponse> open(OpenIndexRequest request) {
        return openIndexAction.execute(request);
    }

    @Override
    public void open(OpenIndexRequest request, ActionListener<OpenIndexResponse> listener) {
        openIndexAction.execute(request, listener);
    }

    @Override
    public ActionFuture<RefreshResponse> refresh(RefreshRequest request) {
        return refreshAction.execute(request);
    }

    @Override
    public void refresh(RefreshRequest request, ActionListener<RefreshResponse> listener) {
        refreshAction.execute(request, listener);
    }

    @Override
    public ActionFuture<FlushResponse> flush(FlushRequest request) {
        return flushAction.execute(request);
    }

    @Override
    public void flush(FlushRequest request, ActionListener<FlushResponse> listener) {
        flushAction.execute(request, listener);
    }

    @Override
    public ActionFuture<OptimizeResponse> optimize(OptimizeRequest request) {
        return optimizeAction.execute(request);
    }

    @Override
    public void optimize(OptimizeRequest request, ActionListener<OptimizeResponse> listener) {
        optimizeAction.execute(request, listener);
    }

    @Override
    public ActionFuture<PutMappingResponse> putMapping(PutMappingRequest request) {
        return putMappingAction.execute(request);
    }

    @Override
    public void putMapping(PutMappingRequest request, ActionListener<PutMappingResponse> listener) {
        putMappingAction.execute(request, listener);
    }

    @Override
    public ActionFuture<DeleteMappingResponse> deleteMapping(DeleteMappingRequest request) {
        return deleteMappingAction.execute(request);
    }

    @Override
    public void deleteMapping(DeleteMappingRequest request, ActionListener<DeleteMappingResponse> listener) {
        deleteMappingAction.execute(request, listener);
    }

    @Override
    public ActionFuture<GatewaySnapshotResponse> gatewaySnapshot(GatewaySnapshotRequest request) {
        return gatewaySnapshotAction.execute(request);
    }

    @Override
    public void gatewaySnapshot(GatewaySnapshotRequest request, ActionListener<GatewaySnapshotResponse> listener) {
        gatewaySnapshotAction.execute(request, listener);
    }

    @Override
    public ActionFuture<IndicesAliasesResponse> aliases(IndicesAliasesRequest request) {
        return indicesAliasesAction.execute(request);
    }

    @Override
    public void aliases(IndicesAliasesRequest request, ActionListener<IndicesAliasesResponse> listener) {
        indicesAliasesAction.execute(request, listener);
    }

    @Override
    public ActionFuture<ClearIndicesCacheResponse> clearCache(ClearIndicesCacheRequest request) {
        return clearIndicesCacheAction.execute(request);
    }

    @Override
    public void clearCache(ClearIndicesCacheRequest request, ActionListener<ClearIndicesCacheResponse> listener) {
        clearIndicesCacheAction.execute(request, listener);
    }

    @Override
    public ActionFuture<UpdateSettingsResponse> updateSettings(UpdateSettingsRequest request) {
        return updateSettingsAction.execute(request);
    }

    @Override
    public void updateSettings(UpdateSettingsRequest request, ActionListener<UpdateSettingsResponse> listener) {
        updateSettingsAction.execute(request, listener);
    }

    @Override
    public ActionFuture<AnalyzeResponse> analyze(AnalyzeRequest request) {
        return analyzeAction.execute(request);
    }

    @Override
    public void analyze(AnalyzeRequest request, ActionListener<AnalyzeResponse> listener) {
        analyzeAction.execute(request, listener);
    }

    @Override
    public ActionFuture<PutIndexTemplateResponse> putTemplate(PutIndexTemplateRequest request) {
        return putIndexTemplateAction.execute(request);
    }

    @Override
    public void putTemplate(PutIndexTemplateRequest request, ActionListener<PutIndexTemplateResponse> listener) {
        putIndexTemplateAction.execute(request, listener);
    }

    @Override
    public ActionFuture<DeleteIndexTemplateResponse> deleteTemplate(DeleteIndexTemplateRequest request) {
        return deleteIndexTemplateAction.execute(request);
    }

    @Override
    public void deleteTemplate(DeleteIndexTemplateRequest request, ActionListener<DeleteIndexTemplateResponse> listener) {
        deleteIndexTemplateAction.execute(request, listener);
    }

    @Override
    public ActionFuture<ValidateQueryResponse> validateQuery(ValidateQueryRequest request) {
        return validateQueryAction.execute(request);
    }

    @Override
    public void validateQuery(ValidateQueryRequest request, ActionListener<ValidateQueryResponse> listener) {
        validateQueryAction.execute(request, listener);
    }
}