org.elasticsearch.cluster.ClusterService Java Examples

@Inject
public ReferenceInfos(Map<String, SchemaInfo> builtInSchemas,
                      ClusterService clusterService,
                      IndexNameExpressionResolver indexNameExpressionResolver,
                      ThreadPool threadPool,
                      Provider<TransportPutIndexTemplateAction> transportPutIndexTemplateAction,
                      Functions functions) {
    this.clusterService = clusterService;
    this.indexNameExpressionResolver = indexNameExpressionResolver;
    this.transportPutIndexTemplateAction = transportPutIndexTemplateAction;
    this.functions = functions;
    this.executorService = (ExecutorService) threadPool.executor(ThreadPool.Names.SUGGEST);
    schemas.putAll(builtInSchemas);
    schemas.remove(BlobSchemaInfo.NAME); // remove blob schema name
    this.builtInSchemas = builtInSchemas;
    clusterService.add(this);
}
 

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

@Inject
public SnapshotShardsService(Settings settings, ClusterService clusterService, SnapshotsService snapshotsService, ThreadPool threadPool,
                             TransportService transportService, IndicesService indicesService) {
    super(settings);
    this.indicesService = indicesService;
    this.snapshotsService = snapshotsService;
    this.transportService = transportService;
    this.clusterService = clusterService;
    this.threadPool = threadPool;
    if (DiscoveryNode.dataNode(settings)) {
        // this is only useful on the nodes that can hold data
        // addLast to make sure that Repository will be created before snapshot
        clusterService.addLast(this);
    }

    if (DiscoveryNode.masterNode(settings)) {
        // This needs to run only on nodes that can become masters
        transportService.registerRequestHandler(UPDATE_SNAPSHOT_ACTION_NAME, UpdateIndexShardSnapshotStatusRequest.class, ThreadPool.Names.SAME, new UpdateSnapshotStateRequestHandler());
    }

}
 

@Inject
public SysShardsTableInfo(ClusterService service, SysNodesTableInfo sysNodesTableInfo) {
    super(IDENT, new ColumnRegistrar(IDENT, RowGranularity.SHARD)
                    .register(Columns.SCHEMA_NAME, StringType.INSTANCE)
                    .register(Columns.TABLE_NAME, StringType.INSTANCE)
                    .register(Columns.ID, IntegerType.INSTANCE)
                    .register(Columns.PARTITION_IDENT, StringType.INSTANCE)
                    .register(Columns.NUM_DOCS, LongType.INSTANCE)
                    .register(Columns.PRIMARY, BooleanType.INSTANCE)
                    .register(Columns.RELOCATING_NODE, StringType.INSTANCE)
                    .register(Columns.SIZE, LongType.INSTANCE)
                    .register(Columns.STATE, StringType.INSTANCE)
                    .register(Columns.ROUTING_STATE, StringType.INSTANCE)
                    .register(Columns.ORPHAN_PARTITION, BooleanType.INSTANCE)

                    .register(Columns.RECOVERY, ObjectType.INSTANCE)
                    .register(Columns.RECOVERY_STAGE, StringType.INSTANCE)
                    .register(Columns.RECOVERY_TYPE, StringType.INSTANCE)
                    .register(Columns.RECOVERY_TOTAL_TIME, LongType.INSTANCE)

                    .register(Columns.RECOVERY_SIZE, ObjectType.INSTANCE)
                    .register(Columns.RECOVERY_SIZE_USED, LongType.INSTANCE)
                    .register(Columns.RECOVERY_SIZE_REUSED, LongType.INSTANCE)
                    .register(Columns.RECOVERY_SIZE_RECOVERED, LongType.INSTANCE)
                    .register(Columns.RECOVERY_SIZE_PERCENT, FloatType.INSTANCE)

                    .register(Columns.RECOVERY_FILES, ObjectType.INSTANCE)
                    .register(Columns.RECOVERY_FILES_USED, IntegerType.INSTANCE)
                    .register(Columns.RECOVERY_FILES_REUSED, IntegerType.INSTANCE)
                    .register(Columns.RECOVERY_FILES_RECOVERED, IntegerType.INSTANCE)
                    .register(Columns.RECOVERY_FILES_PERCENT, FloatType.INSTANCE)
                    .putInfoOnly(SysNodesTableInfo.SYS_COL_IDENT, SysNodesTableInfo.tableColumnInfo(IDENT)),
            PRIMARY_KEY);
    this.service = service;
    nodesTableColumn = sysNodesTableInfo.tableColumn();
}
 

@Inject
public ClusterSettingsExpression(Settings settings, NodeSettingsService nodeSettingsService, ClusterService clusterService) {
    this.clusterService = clusterService;
    setDefaultValues(CrateSettings.SETTINGS);
    ApplySettings applySettings = new ApplySettings(settings, values);

    nodeSettingsService.addListener(applySettings);
    addChildImplementations();
}
 

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

@Inject
public TransportPutIndexTemplateAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                       ThreadPool threadPool, MetaDataIndexTemplateService indexTemplateService,
                                       ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, PutIndexTemplateAction.NAME, transportService, clusterService, threadPool, actionFilters, indexNameExpressionResolver, PutIndexTemplateRequest.class);
    this.indexTemplateService = indexTemplateService;
}
 

@Inject
public TransportClearScrollAction(Settings settings, TransportService transportService, ThreadPool threadPool,
                                  ClusterService clusterService, SearchServiceTransportAction searchServiceTransportAction,
                                  ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ClearScrollAction.NAME, threadPool, transportService, actionFilters, indexNameExpressionResolver, ClearScrollRequest.class);
    this.clusterService = clusterService;
    this.searchServiceTransportAction = searchServiceTransportAction;
}
 

SearchCountAsyncAction(ESLogger logger, SearchServiceTransportAction searchService, ClusterService clusterService,
                                    IndexNameExpressionResolver indexNameExpressionResolver,
                                    SearchPhaseController searchPhaseController, ThreadPool threadPool, SearchRequest request,
                                    ActionListener<SearchResponse> listener) {
    super(logger, searchService, clusterService, indexNameExpressionResolver, searchPhaseController, threadPool,
            request, listener);
}
 

@Inject
public TransportClearFilterJoinCacheAction(Settings settings, ClusterName clusterName, ThreadPool threadPool,
                                              ClusterService clusterService, FilterJoinCacheService cacheService,
                                              TransportService transportService, ActionFilters actionFilters,
                                              IndexNameExpressionResolver indexNameExpressionResolver) {
  super(settings, ClearFilterJoinCacheAction.NAME, clusterName, threadPool, clusterService, transportService,
          actionFilters, indexNameExpressionResolver, ClearFilterJoinCacheRequest.class,
          ClearFilterJoinCacheNodeRequest.class, ThreadPool.Names.MANAGEMENT);
  this.cacheService = cacheService;
  this.clusterService = clusterService;
}
 

@Inject
public TransportNodesHotThreadsAction(Settings settings, ClusterName clusterName, ThreadPool threadPool,
                                      ClusterService clusterService, TransportService transportService,
                                      ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, NodesHotThreadsAction.NAME, clusterName, threadPool, clusterService, transportService, actionFilters,
            indexNameExpressionResolver, NodesHotThreadsRequest.class, NodeRequest.class, ThreadPool.Names.GENERIC);
}
 

@Inject
public TransportShardDeleteAction(Settings settings,
                                  TransportService transportService,
                                  MappingUpdatedAction mappingUpdatedAction,
                                  IndexNameExpressionResolver indexNameExpressionResolver,
                                  ClusterService clusterService,
                                  IndicesService indicesService,
                                  ThreadPool threadPool,
                                  ShardStateAction shardStateAction,
                                  ActionFilters actionFilters) {
    super(settings, ACTION_NAME, transportService, mappingUpdatedAction, indexNameExpressionResolver,
            clusterService, indicesService, threadPool, shardStateAction, actionFilters, ShardDeleteRequest.class);
}
 

@Inject
public TransportGetAction(Settings settings, ClusterService clusterService, TransportService transportService,
                          IndicesService indicesService, ThreadPool threadPool, ActionFilters actionFilters,
                          IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, GetAction.NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver,
            GetRequest.class, ThreadPool.Names.GET);
    this.indicesService = indicesService;

    this.realtime = settings.getAsBoolean("action.get.realtime", true);
}
 

public UpsertByIdTask(UUID jobId,
                      ClusterService clusterService,
                      IndexNameExpressionResolver indexNameExpressionResolver,
                      Settings settings,
                      BulkRequestExecutor<ShardUpsertRequest> transportShardUpsertActionDelegate,
                      TransportCreateIndexAction transportCreateIndexAction,
                      TransportBulkCreateIndicesAction transportBulkCreateIndicesAction,
                      BulkRetryCoordinatorPool bulkRetryCoordinatorPool,
                      UpsertByIdNode node,
                      JobContextService jobContextService) {
    super(jobId);
    this.indexNameExpressionResolver = indexNameExpressionResolver;
    this.transportShardUpsertActionDelegate = transportShardUpsertActionDelegate;
    this.transportCreateIndexAction = transportCreateIndexAction;
    this.transportBulkCreateIndicesAction = transportBulkCreateIndicesAction;
    this.clusterService = clusterService;
    this.node = node;
    this.bulkRetryCoordinatorPool = bulkRetryCoordinatorPool;
    this.jobContextService = jobContextService;
    autoCreateIndex = new AutoCreateIndex(settings, indexNameExpressionResolver);

    if (node.items().size() == 1) {
        // skip useless usage of bulk processor if only 1 item in statement
        // and instead create upsert request directly on start()
        resultList = new ArrayList<>(1);
        resultList.add(SettableFuture.<TaskResult>create());
    } else {
        resultList = initializeBulkShardProcessor(settings);
    }

}
 

@Inject
public AbstractTransportImportAction(Settings settings, ClusterName clusterName,
                                     ThreadPool threadPool, ClusterService clusterService,
                                     TransportService transportService, IImportParser importParser, Importer importer, NodeEnvironment nodeEnv) {
    super(settings, clusterName, threadPool, clusterService, transportService);
    this.importParser = importParser;
    this.importer = importer;

    File[] paths = nodeEnv.nodeDataLocations();
    if (paths.length > 0) {
        nodePath = paths[0].getAbsolutePath();
    }
}
 

@Inject
public TransportGathererAction(Settings settings, ClusterName clusterName, ThreadPool threadPool,
                                ClusterService clusterService, TransportService transportService,
                                NodeService nodeService) {
    super(settings, clusterName, threadPool, clusterService, transportService);
    this.nodeService = nodeService;
}
 

@Inject
public ShardPartitionOrphanedExpression(ShardId shardId, ClusterService clusterService) {
    this.clusterService = clusterService;
    isPartition = PartitionName.isPartition(shardId.getIndex());
    if (isPartition) {
        PartitionName partitionName = PartitionName.fromIndexOrTemplate(shardId.getIndex());
        aliasName = partitionName.tableIdent().indexName();
        templateName = PartitionName.templateName(
                partitionName.tableIdent().schema(),
                partitionName.tableIdent().name());
    } else {
        templateName = null;
        aliasName = null;
    }
}
 

public BlobTableInfoBuilder(TableIdent ident,
                            ClusterService clusterService,
                            IndexNameExpressionResolver indexNameExpressionResolver,
                            BlobEnvironment blobEnvironment,
                            Environment environment,
                            Functions functions) {
    this.clusterService = clusterService;
    this.indexNameExpressionResolver = indexNameExpressionResolver;
    this.blobEnvironment = blobEnvironment;
    this.environment = environment;
    this.functions = functions;
    this.state = clusterService.state();
    this.metaData = state.metaData();
    this.ident = ident;
}
 

DMLProjector(ClusterService clusterService,
                    Settings settings,
                    ShardId shardId,
                    TransportActionProvider transportActionProvider,
                    BulkRetryCoordinatorPool bulkRetryCoordinatorPool,
                    CollectExpression<Row, ?> collectUidExpression,
                    UUID jobId) {
    this.clusterService = clusterService;
    this.settings = settings;
    this.transportActionProvider = transportActionProvider;
    this.bulkRetryCoordinatorPool = bulkRetryCoordinatorPool;
    this.shardId = shardId;
    this.collectUidExpression = collectUidExpression;
    this.jobId = jobId;
}
 

@Inject
public TransportCloseIndexAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                 ThreadPool threadPool, MetaDataIndexStateService indexStateService,
                                 NodeSettingsService nodeSettingsService, ActionFilters actionFilters,
                                 IndexNameExpressionResolver indexNameExpressionResolver, DestructiveOperations destructiveOperations) {
    super(settings, CloseIndexAction.NAME, transportService, clusterService, threadPool, actionFilters, indexNameExpressionResolver, CloseIndexRequest.class);
    this.indexStateService = indexStateService;
    this.destructiveOperations = destructiveOperations;
    this.closeIndexEnabled = settings.getAsBoolean(SETTING_CLUSTER_INDICES_CLOSE_ENABLE, true);
    nodeSettingsService.addListener(this);
}
 

@Inject
public TransportFieldStatsTransportAction(Settings settings, ThreadPool threadPool, ClusterService clusterService,
                                          TransportService transportService, ActionFilters actionFilters,
                                          IndexNameExpressionResolver indexNameExpressionResolver, IndicesService indicesService) {
    super(settings, FieldStatsAction.NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver, FieldStatsRequest.class, FieldStatsShardRequest.class, ThreadPool.Names.MANAGEMENT);
    this.indicesService = indicesService;
}
 

@Inject
public InternalRowDownstreamFactory(Settings settings,
                                    ClusterService clusterService,
                                    TransportDistributedResultAction transportDistributedResultAction) {
    super(settings);
    this.clusterService = clusterService;
    this.transportDistributedResultAction = transportDistributedResultAction;
    distributingDownstreamLogger = Loggers.getLogger(DistributingDownstream.class, settings);
}
 

@Inject
public TransportExplainAction(Settings settings, ThreadPool threadPool, ClusterService clusterService,
                              TransportService transportService, IndicesService indicesService,
                              ScriptService scriptService, PageCacheRecycler pageCacheRecycler,
                              BigArrays bigArrays, ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ExplainAction.NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver,
            ExplainRequest.class, ThreadPool.Names.GET);
    this.indicesService = indicesService;
    this.scriptService = scriptService;
    this.pageCacheRecycler = pageCacheRecycler;
    this.bigArrays = bigArrays;
}
 

@Inject
public TransportForceMergeAction(Settings settings, ThreadPool threadPool, ClusterService clusterService,
                               TransportService transportService, IndicesService indicesService,
                               ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ForceMergeAction.NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver,
            ForceMergeRequest.class, ThreadPool.Names.FORCE_MERGE);
    this.indicesService = indicesService;
}
 

@Inject
protected SysOperationsLogTableInfo(ClusterService clusterService) {
    super(IDENT, new ColumnRegistrar(IDENT, RowGranularity.DOC)
        .register(Columns.ID, DataTypes.STRING)
        .register(Columns.JOB_ID, DataTypes.STRING)
        .register(Columns.NAME, DataTypes.STRING)
        .register(Columns.STARTED, DataTypes.TIMESTAMP)
        .register(Columns.ENDED, DataTypes.TIMESTAMP)
        .register(Columns.USED_BYTES, DataTypes.LONG)
        .register(Columns.ERROR, DataTypes.STRING), Collections.<ColumnIdent>emptyList());
    this.clusterService = clusterService;
}
 

/**
 * DocSchemaInfo constructor for the default (doc) schema.
 */
@Inject
public DocSchemaInfo(ClusterService clusterService,
                     ThreadPool threadPool,
                     Provider<TransportPutIndexTemplateAction> transportPutIndexTemplateAction,
                     IndexNameExpressionResolver indexNameExpressionResolver,
                     Functions functions) {
    this(Schemas.DEFAULT_SCHEMA_NAME,
            clusterService,
            indexNameExpressionResolver,
            (ExecutorService) threadPool.executor(ThreadPool.Names.SUGGEST),
            transportPutIndexTemplateAction, functions,
            Predicates.and(Predicates.notNull(), DOC_SCHEMA_TABLES_FILTER),
            AS_IS_FUNCTION);
}
 

@Inject
public TransportCreateSnapshotAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                     ThreadPool threadPool, SnapshotsService snapshotsService, ActionFilters actionFilters,
                                     IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, CreateSnapshotAction.NAME, transportService, clusterService, threadPool, actionFilters, indexNameExpressionResolver, CreateSnapshotRequest.class);
    this.snapshotsService = snapshotsService;
}
 

@Inject
public TransportMultiPercolateAction(Settings settings, ThreadPool threadPool, TransportShardMultiPercolateAction shardMultiPercolateAction,
                                     ClusterService clusterService, TransportService transportService, PercolatorService percolatorService,
                                     TransportMultiGetAction multiGetAction, ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, MultiPercolateAction.NAME, threadPool, transportService, actionFilters, indexNameExpressionResolver, MultiPercolateRequest.class);
    this.shardMultiPercolateAction = shardMultiPercolateAction;
    this.clusterService = clusterService;
    this.percolatorService = percolatorService;
    this.multiGetAction = multiGetAction;
}
 

@Inject
public TransportDeleteRepositoryAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                       RepositoriesService repositoriesService, ThreadPool threadPool, ActionFilters actionFilters,
                                       IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, DeleteRepositoryAction.NAME, transportService, clusterService, threadPool, actionFilters, indexNameExpressionResolver, DeleteRepositoryRequest.class);
    this.repositoriesService = repositoriesService;
}
 

protected TransportSingleShardAction(Settings settings, String actionName, ThreadPool threadPool, ClusterService clusterService,
                                     TransportService transportService, ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver,
                                     Class<Request> request, String executor) {
    super(settings, actionName, threadPool, actionFilters, indexNameExpressionResolver, transportService.getTaskManager());
    this.clusterService = clusterService;
    this.transportService = transportService;

    this.transportShardAction = actionName + "[s]";
    this.executor = executor;

    if (!isSubAction()) {
        transportService.registerRequestHandler(actionName, request, ThreadPool.Names.SAME, new TransportHandler());
    }
    transportService.registerRequestHandler(transportShardAction, request, executor, new ShardTransportHandler());
}