Java IndexNameExpressionResolver类代码示例

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);
}