import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
TestTransportBulkAction(
        Settings settings,
        ThreadPool threadPool,
        TransportService transportService,
        ClusterService clusterService,
        TransportShardBulkAction shardBulkAction,
        TransportCreateIndexAction createIndexAction,
        ActionFilters actionFilters,
        IndexNameExpressionResolver indexNameExpressionResolver,
        AutoCreateIndex autoCreateIndex,
        LongSupplier relativeTimeProvider) {
    super(
            settings,
            threadPool,
            transportService,
            clusterService,
            null,
            shardBulkAction,
            createIndexAction,
            actionFilters,
            indexNameExpressionResolver,
            autoCreateIndex,
            relativeTimeProvider);
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
public UpdateProjector(ClusterService clusterService,
                       IndexNameExpressionResolver indexNameExpressionResolver,
                       Settings settings,
                       ShardId shardId,
                       TransportActionProvider transportActionProvider,
                       BulkRetryCoordinatorPool bulkRetryCoordinatorPool,
                       CollectExpression<Row, ?> collectUidExpression,
                       String[] assignmentsColumns,
                       Symbol[] assignments,
                       @Nullable Long requiredVersion,
                       UUID jobId) {
    super(clusterService, settings, shardId, transportActionProvider, bulkRetryCoordinatorPool,
            collectUidExpression, jobId);
    this.indexNameExpressionResolver = indexNameExpressionResolver;
    this.assignmentsColumns = assignmentsColumns;
    this.assignments = assignments;
    this.requiredVersion = requiredVersion;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
public void testUpdate() {
    boolean value = randomBoolean();
    Settings settings;
    if (value && randomBoolean()) {
        settings = Settings.EMPTY;
    } else {
        settings = Settings.builder().put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), value).build();
    }

    ClusterSettings clusterSettings = new ClusterSettings(settings,
            ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
    AutoCreateIndex  autoCreateIndex = new AutoCreateIndex(settings, clusterSettings, new IndexNameExpressionResolver(settings));
    assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(value));

    Settings newSettings = Settings.builder().put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), !value).build();
    clusterSettings.applySettings(newSettings);
    assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(!value));

    newSettings = Settings.builder().put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), "logs-*").build();
    clusterSettings.applySettings(newSettings);
    assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(true));
    assertThat(autoCreateIndex.getAutoCreate().getExpressions().size(), equalTo(1));
    assertThat(autoCreateIndex.getAutoCreate().getExpressions().get(0).v1(), equalTo("logs-*"));
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
protected TransportNodesAction(Settings settings, String actionName, ThreadPool threadPool,
                               ClusterService clusterService, TransportService transportService, ActionFilters actionFilters,
                               IndexNameExpressionResolver indexNameExpressionResolver,
                               Supplier<NodesRequest> request, Supplier<NodeRequest> nodeRequest,
                               String nodeExecutor,
                               Class<NodeResponse> nodeResponseClass) {
    super(settings, actionName, threadPool, transportService, actionFilters, indexNameExpressionResolver, request);
    this.clusterService = Objects.requireNonNull(clusterService);
    this.transportService = Objects.requireNonNull(transportService);
    this.nodeResponseClass = Objects.requireNonNull(nodeResponseClass);

    this.transportNodeAction = actionName + "[n]";

    transportService.registerRequestHandler(
        transportNodeAction, nodeRequest, nodeExecutor, new NodeTransportHandler());
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportCancelTasksAction(Settings settings, ClusterName clusterName, ThreadPool threadPool, ClusterService clusterService,
                                  TransportService transportService, ActionFilters actionFilters, IndexNameExpressionResolver
                                      indexNameExpressionResolver) {
    super(settings, CancelTasksAction.NAME, clusterName, threadPool, clusterService, transportService, actionFilters,
        indexNameExpressionResolver, new Callable<CancelTasksRequest>() {
            @Override
            public CancelTasksRequest call() throws Exception {
                return new CancelTasksRequest();
            }
        }, ThreadPool.Names.MANAGEMENT);
    transportService.registerRequestHandler(BAN_PARENT_ACTION_NAME, new Callable<BanParentTaskRequest>() {
        @Override
        public BanParentTaskRequest call() throws Exception {
            return new BanParentTaskRequest();
        }
    }, ThreadPool.Names.SAME, new
        BanParentRequestHandler());
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
public TransportBroadcastByNodeAction(
        Settings settings,
        String actionName,
        ThreadPool threadPool,
        ClusterService clusterService,
        TransportService transportService,
        ActionFilters actionFilters,
        IndexNameExpressionResolver indexNameExpressionResolver,
        Supplier<Request> request,
        String executor,
        boolean canTripCircuitBreaker) {
    super(settings, actionName, canTripCircuitBreaker, threadPool, transportService, actionFilters, indexNameExpressionResolver,
        request);

    this.clusterService = clusterService;
    this.transportService = transportService;

    transportNodeBroadcastAction = actionName + "[n]";

    transportService.registerRequestHandler(transportNodeBroadcastAction, NodeRequest::new, executor, false, canTripCircuitBreaker,
        new BroadcastByNodeTransportRequestHandler());
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
protected TransportTasksAction(Settings settings, String actionName, ClusterName clusterName, ThreadPool threadPool,
                               ClusterService clusterService, TransportService transportService, ActionFilters actionFilters,
                               IndexNameExpressionResolver indexNameExpressionResolver, Callable<TasksRequest> requestFactory,
                               String nodeExecutor) {
    super(settings, actionName, threadPool, transportService, actionFilters, indexNameExpressionResolver, requestFactory);
    this.clusterName = clusterName;
    this.clusterService = clusterService;
    this.transportService = transportService;
    this.transportNodeAction = actionName + "[n]";
    this.requestFactory = requestFactory;

    transportService.registerRequestHandler(transportNodeAction, new Callable<NodeTaskRequest>() {
        @Override
        public NodeTaskRequest call() throws Exception {
            return new NodeTaskRequest();
        }
    }, nodeExecutor, new NodeTransportHandler());
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportMultiTermVectorsAction(Settings settings, ThreadPool threadPool, TransportService transportService,
                                       ClusterService clusterService, TransportShardMultiTermsVectorAction shardAction,
                                       ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, MultiTermVectorsAction.NAME, threadPool, transportService, actionFilters, indexNameExpressionResolver, MultiTermVectorsRequest.class);
    this.clusterService = clusterService;
    this.shardAction = shardAction;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportMultiSearchTemplateAction(Settings settings, ThreadPool threadPool, TransportService transportService,
                                          ActionFilters actionFilters, IndexNameExpressionResolver resolver,
                                          TransportSearchTemplateAction searchTemplateAction) {
    super(settings, MultiSearchTemplateAction.NAME, threadPool, transportService, actionFilters, resolver,
            MultiSearchTemplateRequest::new);
    this.searchTemplateAction = searchTemplateAction;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportUpdateByQueryAction(Settings settings, ThreadPool threadPool, ActionFilters actionFilters,
        IndexNameExpressionResolver indexNameExpressionResolver, Client client, TransportService transportService,
        ScriptService scriptService, ClusterService clusterService) {
    super(settings, UpdateByQueryAction.NAME, threadPool, transportService, actionFilters,
            indexNameExpressionResolver, UpdateByQueryRequest::new);
    this.client = client;
    this.scriptService = scriptService;
    this.clusterService = clusterService;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportRethrottleAction(Settings settings, ThreadPool threadPool, ClusterService clusterService,
        TransportService transportService, ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver,
        Client client) {
    super(settings, RethrottleAction.NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver,
            RethrottleRequest::new, ListTasksResponse::new, ThreadPool.Names.MANAGEMENT);
    this.client = client;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportReindexAction(Settings settings, ThreadPool threadPool, ActionFilters actionFilters,
        IndexNameExpressionResolver indexNameExpressionResolver, ClusterService clusterService, ScriptService scriptService,
        AutoCreateIndex autoCreateIndex, Client client, TransportService transportService) {
    super(settings, ReindexAction.NAME, threadPool, transportService, actionFilters, indexNameExpressionResolver,
            ReindexRequest::new);
    this.clusterService = clusterService;
    this.scriptService = scriptService;
    this.autoCreateIndex = autoCreateIndex;
    this.client = client;
    remoteWhitelist = buildRemoteWhitelist(REMOTE_CLUSTER_WHITELIST.get(settings));
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportClusterUpdateSettingsAction(Settings settings, TransportService transportService, ClusterService clusterService, ThreadPool threadPool,
                                            AllocationService allocationService, @ClusterDynamicSettings DynamicSettings dynamicSettings,
                                            ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ClusterUpdateSettingsAction.NAME, transportService, clusterService, threadPool, actionFilters, indexNameExpressionResolver, ClusterUpdateSettingsRequest.class);
    this.allocationService = allocationService;
    this.dynamicSettings = dynamicSettings;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportGetSnapshotsAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                   ThreadPool threadPool, SnapshotsService snapshotsService, ActionFilters actionFilters,
                                   IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, GetSnapshotsAction.NAME, transportService, clusterService, threadPool, actionFilters, indexNameExpressionResolver, GetSnapshotsRequest.class);
    this.snapshotsService = snapshotsService;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportBulkAction(Settings settings, ThreadPool threadPool, TransportService transportService, ClusterService clusterService,
                           TransportShardBulkAction shardBulkAction, TransportCreateIndexAction createIndexAction,
                           ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver,
                           AutoCreateIndex autoCreateIndex) {
    super(settings, BulkAction.NAME, threadPool, transportService, actionFilters, indexNameExpressionResolver, BulkRequest.class);
    this.clusterService = clusterService;
    this.shardBulkAction = shardBulkAction;
    this.createIndexAction = createIndexAction;

    this.autoCreateIndex = autoCreateIndex;
    this.allowIdGeneration = this.settings.getAsBoolean("action.bulk.action.allow_id_generation", true);
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportShardFlushAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                 IndicesService indicesService, ThreadPool threadPool, ShardStateAction shardStateAction,
                                 MappingUpdatedAction mappingUpdatedAction, ActionFilters actionFilters,
                                 IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, NAME, transportService, clusterService, indicesService, threadPool, shardStateAction, mappingUpdatedAction,
            actionFilters, indexNameExpressionResolver, ShardFlushRequest.class, ShardFlushRequest.class, ThreadPool.Names.FLUSH);
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportShardBulkAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                IndicesService indicesService, ThreadPool threadPool, ShardStateAction shardStateAction,
                                MappingUpdatedAction mappingUpdatedAction, UpdateHelper updateHelper, ActionFilters actionFilters,
                                IndexNameExpressionResolver indexNameExpressionResolver, FsService fsService) {
    super(settings, ACTION_NAME, transportService, clusterService, indicesService, threadPool, shardStateAction, mappingUpdatedAction,
            actionFilters, indexNameExpressionResolver,
            BulkShardRequest.class, BulkShardRequest.class, ThreadPool.Names.BULK);
    this.updateHelper = updateHelper;
    this.allowIdGeneration = settings.getAsBoolean("action.allow_id_generation", true);
    this.fsService = fsService;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportClearScrollAction(Settings settings, TransportService transportService, ThreadPool threadPool,
                                  ClusterService clusterService, ActionFilters actionFilters,
                                  IndexNameExpressionResolver indexNameExpressionResolver,
                                  SearchTransportService searchTransportService) {
    super(settings, ClearScrollAction.NAME, threadPool, transportService, actionFilters, indexNameExpressionResolver, ClearScrollRequest::new);
    this.clusterService = clusterService;
    this.searchTransportService = searchTransportService;
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public GlobalCheckpointSyncAction(Settings settings, TransportService transportService,
                                  ClusterService clusterService, IndicesService indicesService,
                                  ThreadPool threadPool, ShardStateAction shardStateAction,
                                  ActionFilters actionFilters,
                                  IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ACTION_NAME, transportService, clusterService, indicesService, threadPool, shardStateAction,
        actionFilters, indexNameExpressionResolver, PrimaryRequest::new, ReplicaRequest::new,
        ThreadPool.Names.SAME);
}
 

import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; //导入依赖的package包/类
@Inject
public TransportShardRefreshAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                   IndicesService indicesService, ThreadPool threadPool, ShardStateAction shardStateAction,
                                   MappingUpdatedAction mappingUpdatedAction, ActionFilters actionFilters,
                                   IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, NAME, transportService, clusterService, indicesService, threadPool, shardStateAction, mappingUpdatedAction,
            actionFilters, indexNameExpressionResolver, ReplicationRequest.class, ReplicationRequest.class, ThreadPool.Names.REFRESH);
}