Java ActionFilters类代码示例

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
protected TransportReplicationAction(Settings settings, String actionName, TransportService transportService,
                                     ClusterService clusterService, IndicesService indicesService,
                                     ThreadPool threadPool, ShardStateAction shardStateAction,
                                     MappingUpdatedAction mappingUpdatedAction, ActionFilters actionFilters,
                                     IndexNameExpressionResolver indexNameExpressionResolver, Class<Request> request,
                                     Class<ReplicaRequest> replicaRequest, String executor) {
    super(settings, actionName, threadPool, actionFilters, indexNameExpressionResolver, transportService.getTaskManager());
    this.transportService = transportService;
    this.clusterService = clusterService;
    this.indicesService = indicesService;
    this.shardStateAction = shardStateAction;
    this.mappingUpdatedAction = mappingUpdatedAction;

    this.transportPrimaryAction = actionName + "[p]";
    this.transportReplicaAction = actionName + "[r]";
    this.executor = executor;
    this.checkWriteConsistency = checkWriteConsistency();
    transportService.registerRequestHandler(actionName, request, ThreadPool.Names.SAME, new OperationTransportHandler());
    transportService.registerRequestHandler(transportPrimaryAction, request, executor, new PrimaryOperationTransportHandler());
    // we must never reject on because of thread pool capacity on replicas
    transportService.registerRequestHandler(transportReplicaAction, replicaRequest, executor, true, new ReplicaOperationTransportHandler());

    this.transportOptions = transportOptions();

    this.defaultWriteConsistencyLevel = WriteConsistencyLevel.fromString(settings.get("action.write_consistency", "quorum"));
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportShardUpsertAction(Settings settings,
                                  ThreadPool threadPool,
                                  ClusterService clusterService,
                                  TransportService transportService,
                                  ActionFilters actionFilters,
                                  JobContextService jobContextService,
                                  IndicesService indicesService,
                                  ShardStateAction shardStateAction,
                                  Functions functions,
                                  Schemas schemas,
                                  MappingUpdatedAction mappingUpdatedAction,
                                  IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ACTION_NAME, transportService, mappingUpdatedAction, indexNameExpressionResolver, clusterService,
            indicesService, threadPool, shardStateAction, actionFilters, ShardUpsertRequest.class);
    this.indicesService = indicesService;
    this.functions = functions;
    this.schemas = schemas;
    jobContextService.addListener(this);
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportSQLAction(
        ClusterService clusterService,
        Settings settings,
        ThreadPool threadPool,
        Analyzer analyzer,
        Planner planner,
        Provider<Executor> executor,
        TransportService transportService,
        StatsTables statsTables,
        ActionFilters actionFilters,
        IndexNameExpressionResolver indexNameExpressionResolver,
        TransportKillJobsNodeAction transportKillJobsNodeAction) {
    super(clusterService, settings, SQLAction.NAME, threadPool,
        analyzer, planner, executor, statsTables, actionFilters,
        indexNameExpressionResolver, transportKillJobsNodeAction,
        transportService.getTaskManager());
    transportService.registerRequestHandler(SQLAction.NAME, SQLRequest.class, ThreadPool.Names.SAME, new TransportHandler());
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的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.action.support.ActionFilters; //导入依赖的package包/类
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    transport = new CapturingTransport();
    clusterService = createClusterService(THREAD_POOL);
    transportService = new TransportService(clusterService.getSettings(), transport, THREAD_POOL,
            TransportService.NOOP_TRANSPORT_INTERCEPTOR, x -> clusterService.localNode(), null);
    transportService.start();
    transportService.acceptIncomingRequests();
    action = new TestTransportInstanceSingleOperationAction(
            Settings.EMPTY,
            "indices:admin/test",
            transportService,
            new ActionFilters(new HashSet<ActionFilter>()),
            new MyResolver(),
            Request::new
    );
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportSQLBulkAction(ClusterService clusterService,
                              Settings settings,
                              ThreadPool threadPool,
                              Analyzer analyzer,
                              Planner planner,
                              Provider<Executor> executor,
                              TransportService transportService,
                              StatsTables statsTables,
                              ActionFilters actionFilters,
                              IndexNameExpressionResolver indexNameExpressionResolver,
                              TransportKillJobsNodeAction transportKillJobsNodeAction) {
    super(clusterService, settings, SQLBulkAction.NAME, threadPool, analyzer,
        planner, executor, statsTables, actionFilters, indexNameExpressionResolver, transportKillJobsNodeAction,
        transportService.getTaskManager());

    transportService.registerRequestHandler(SQLBulkAction.NAME, SQLBulkRequest.class, ThreadPool.Names.SAME, new TransportHandler());
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportNodesListShardStoreMetaData(Settings settings, ClusterName clusterName, ThreadPool threadPool, ClusterService clusterService, TransportService transportService,
                                            IndicesService indicesService, NodeEnvironment nodeEnv, ActionFilters actionFilters,
                                            IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ACTION_NAME, clusterName, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver,
            Request.class, NodeRequest.class, ThreadPool.Names.FETCH_SHARD_STORE);
    this.indicesService = indicesService;
    this.nodeEnv = nodeEnv;
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的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.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportDeleteByQueryAction(Settings settings, ThreadPool threadPool, ActionFilters actionFilters,
                                    IndexNameExpressionResolver resolver, Client client, TransportService transportService,
                                    ScriptService scriptService, ClusterService clusterService) {
    super(settings, DeleteByQueryAction.NAME, threadPool, transportService, actionFilters, resolver, DeleteByQueryRequest::new);
    this.client = client;
    this.scriptService = scriptService;
    this.clusterService = clusterService;
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportNodesListShardStoreMetaData(Settings settings, ThreadPool threadPool,
                                            ClusterService clusterService, TransportService transportService,
                                            IndicesService indicesService, NodeEnvironment nodeEnv, ActionFilters actionFilters,
                                            IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ACTION_NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver,
        Request::new, NodeRequest::new, ThreadPool.Names.FETCH_SHARD_STORE, NodeStoreFilesMetaData.class);
    this.indicesService = indicesService;
    this.nodeEnv = nodeEnv;
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的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.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportPercolateAction(Settings settings, ThreadPool threadPool, ClusterService clusterService,
                                TransportService transportService, PercolatorService percolatorService,
                                TransportGetAction getAction, ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, PercolateAction.NAME, threadPool, clusterService, transportService, actionFilters,
            indexNameExpressionResolver, PercolateRequest.class, PercolateShardRequest.class, ThreadPool.Names.PERCOLATE);
    this.percolatorService = percolatorService;
    this.getAction = getAction;
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportTestTaskAction(Settings settings, ThreadPool threadPool,
                               ClusterService clusterService, TransportService transportService) {
    super(settings, TestTaskAction.NAME, threadPool, clusterService, transportService,
          new ActionFilters(new HashSet<>()), new IndexNameExpressionResolver(Settings.EMPTY),
          NodesRequest::new, NodeRequest::new, ThreadPool.Names.GENERIC, NodeResponse.class);
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    MockTcpTransport transport = new MockTcpTransport(Settings.EMPTY,
        threadPool, BigArrays.NON_RECYCLING_INSTANCE, circuitBreakerService, new NamedWriteableRegistry(Collections.emptyList()),
        new NetworkService(Settings.EMPTY, Collections.emptyList()));
    clusterService = createClusterService(threadPool);
    transportService = new TransportService(clusterService.getSettings(), transport, threadPool,
            TransportService.NOOP_TRANSPORT_INTERCEPTOR, x -> clusterService.localNode(), null);
    transportService.start();
    transportService.acceptIncomingRequests();
    broadcastReplicationAction = new TestBroadcastReplicationAction(Settings.EMPTY, threadPool, clusterService, transportService,
            new ActionFilters(new HashSet<>()), new IndexNameExpressionResolver(Settings.EMPTY), null);
}
 

import org.elasticsearch.action.support.ActionFilters; //导入依赖的package包/类
@Inject
public TransportUpgradeStatusAction(Settings settings, ThreadPool threadPool, ClusterService clusterService, TransportService transportService,
                                    IndicesService indicesService, ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, UpgradeStatusAction.NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver,
            UpgradeStatusRequest.class, ThreadPool.Names.MANAGEMENT);
    this.indicesService = indicesService;
}