org.elasticsearch.threadpool.ThreadPool Java Examples

public FaultDetection(Settings settings, ThreadPool threadPool, TransportService transportService, ClusterName clusterName) {
    super(settings);
    this.threadPool = threadPool;
    this.transportService = transportService;
    this.clusterName = clusterName;

    this.connectOnNetworkDisconnect = settings.getAsBoolean(SETTING_CONNECT_ON_NETWORK_DISCONNECT, false);
    this.pingInterval = settings.getAsTime(SETTING_PING_INTERVAL, timeValueSeconds(1));
    this.pingRetryTimeout = settings.getAsTime(SETTING_PING_TIMEOUT, timeValueSeconds(30));
    this.pingRetryCount = settings.getAsInt(SETTING_PING_RETRIES, 3);
    this.registerConnectionListener = settings.getAsBoolean(SETTING_REGISTER_CONNECTION_LISTENER, true);

    this.connectionListener = new FDConnectionListener();
    if (registerConnectionListener) {
        transportService.addConnectionListener(connectionListener);
    }
}
 

@VisibleForTesting
NodeStatsContextFieldResolver(Supplier<DiscoveryNode> localNode,
                              MonitorService monitorService,
                              Supplier<TransportAddress> boundHttpAddress,
                              Supplier<HttpStats> httpStatsSupplier,
                              ThreadPool threadPool,
                              ExtendedNodeInfo extendedNodeInfo,
                              Supplier<ConnectionStats> psqlStats,
                              Supplier<TransportAddress> boundPostgresAddress,
                              LongSupplier numOpenTransportConnections,
                              LongSupplier clusterStateVersion) {
    this.localNode = localNode;
    processService = monitorService.processService();
    osService = monitorService.osService();
    jvmService = monitorService.jvmService();
    fsService = monitorService.fsService();
    this.httpStatsSupplier = httpStatsSupplier;
    this.boundHttpAddress = boundHttpAddress;
    this.threadPool = threadPool;
    this.extendedNodeInfo = extendedNodeInfo;
    this.psqlStats = psqlStats;
    this.boundPostgresAddress = boundPostgresAddress;
    this.numOpenTransportConnections = numOpenTransportConnections;
    this.clusterStateVersion = clusterStateVersion;
}
 

@Inject
public InternalUsersApiAction(final Settings settings, final Path configPath, final RestController controller,
        final Client client, final AdminDNs adminDNs, final ConfigurationRepository cl,
        final ClusterService cs, final PrincipalExtractor principalExtractor, final PrivilegesEvaluator evaluator,
        ThreadPool threadPool, AuditLog auditLog) {
    super(settings, configPath, controller, client, adminDNs, cl, cs, principalExtractor, evaluator, threadPool,
            auditLog);

    // legacy mapping for backwards compatibility
    // TODO: remove in next version
    controller.registerHandler(Method.GET, "/_opendistro/_security/api/user/{name}", this);
    controller.registerHandler(Method.GET, "/_opendistro/_security/api/user/", this);
    controller.registerHandler(Method.DELETE, "/_opendistro/_security/api/user/{name}", this);
    controller.registerHandler(Method.PUT, "/_opendistro/_security/api/user/{name}", this);

    // corrected mapping, introduced in Open Distro Security
    controller.registerHandler(Method.GET, "/_opendistro/_security/api/internalusers/{name}", this);
    controller.registerHandler(Method.GET, "/_opendistro/_security/api/internalusers/", this);
    controller.registerHandler(Method.DELETE, "/_opendistro/_security/api/internalusers/{name}", this);
    controller.registerHandler(Method.PUT, "/_opendistro/_security/api/internalusers/{name}", this);
    controller.registerHandler(Method.PATCH, "/_opendistro/_security/api/internalusers/", this);
    controller.registerHandler(Method.PATCH, "/_opendistro/_security/api/internalusers/{name}", this);

}
 

@Override
protected void doRun() throws Exception {
    RecoveryStatus status = onGoingRecoveries.get(recoveryId);
    if (status == null) {
        logger.trace("[monitor] no status found for [{}], shutting down", recoveryId);
        return;
    }
    long accessTime = status.lastAccessTime();
    if (accessTime == lastSeenAccessTime) {
        String message = "no activity after [" + checkInterval + "]";
        failRecovery(recoveryId,
                new RecoveryFailedException(status.state(), message, new ElasticsearchTimeoutException(message)),
                true // to be safe, we don't know what go stuck
        );
        return;
    }
    lastSeenAccessTime = accessTime;
    logger.trace("[monitor] rescheduling check for [{}]. last access time is [{}]", recoveryId, lastSeenAccessTime);
    threadPool.schedule(checkInterval, ThreadPool.Names.GENERIC, this);
}
 

/**
    * Build the service.
    *
    * @param clusterSettings if non null, the {@linkplain TransportService} will register with the {@link ClusterSettings} for settings
*        updates for {@link TransportSettings#TRACE_LOG_EXCLUDE_SETTING} and {@link TransportSettings#TRACE_LOG_INCLUDE_SETTING}.
    */
   public TransportService(Settings settings,
                           Transport transport,
                           ThreadPool threadPool,
                           TransportInterceptor transportInterceptor,
                           Function<BoundTransportAddress, DiscoveryNode> localNodeFactory,
                           @Nullable ClusterSettings clusterSettings) {
       this(
           settings,
           transport,
           threadPool,
           transportInterceptor,
           localNodeFactory,
           clusterSettings,
           new ConnectionManager(settings, transport, threadPool)
       );
   }
 

/**
 * Build the service.
 *
 * @param clusterSettings if non null the {@linkplain TransportService} will register with the {@link ClusterSettings} for settings
 *                        updates for {@link TransportSettings#TRACE_LOG_EXCLUDE_SETTING} and {@link TransportSettings#TRACE_LOG_INCLUDE_SETTING}.
 */
public MockTransportService(Settings settings, Transport transport, ThreadPool threadPool, TransportInterceptor interceptor,
                            @Nullable ClusterSettings clusterSettings) {
    this(
        settings,
        transport,
        threadPool,
        interceptor,
        (boundAddress) -> DiscoveryNode.createLocal(
            settings,
            boundAddress.publishAddress(),
            settings.get(Node.NODE_NAME_SETTING.getKey(),
            UUIDs.randomBase64UUID())
        ),
        clusterSettings
    );
}
 

@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    clusterService = mock(ClusterService.class);
    threadPool = mock(ThreadPool.class);
    hourlyCancellable = mock(Cancellable.class);
    dailyCancellable = mock(Cancellable.class);
    when(threadPool.scheduleWithFixedDelay(any(HourlyCron.class), any(TimeValue.class), any(String.class)))
        .thenReturn(hourlyCancellable);
    when(threadPool.scheduleWithFixedDelay(any(DailyCron.class), any(TimeValue.class), any(String.class))).thenReturn(dailyCancellable);
    client = mock(Client.class);
    clock = mock(Clock.class);
    clientUtil = mock(ClientUtil.class);
    HashMap<String, String> ignoredAttributes = new HashMap<String, String>();
    ignoredAttributes.put(CommonName.BOX_TYPE_KEY, CommonName.WARM_BOX_TYPE);
    nodeFilter = new DiscoveryNodeFilterer(clusterService);

    masterService = new MasterEventListener(clusterService, threadPool, client, clock, clientUtil, nodeFilter);
}
 

protected void registerRequestHandlers(String actionName,
                                       TransportService transportService,
                                       Writeable.Reader<Request> reader,
                                       Writeable.Reader<ReplicaRequest> replicaRequestReader,
                                       String executor) {
    transportService.registerRequestHandler(actionName, reader, ThreadPool.Names.SAME, new OperationTransportHandler());
    transportService.registerRequestHandler(
        transportPrimaryAction, in -> new ConcreteShardRequest<>(in, reader), executor, new PrimaryOperationTransportHandler());
    // we must never reject on because of thread pool capacity on replicas
    transportService.registerRequestHandler(
        transportReplicaAction,
        in -> new ConcreteReplicaRequest<>(in, replicaRequestReader),
        executor,
        true,
        true,
        new ReplicaOperationTransportHandler());
}
 

@Inject
public TransportUpgradeSettingsAction(TransportService transportService,
                                      ClusterService clusterService,
                                      ThreadPool threadPool,
                                      MetaDataUpdateSettingsService updateSettingsService,
                                      IndexNameExpressionResolver indexNameExpressionResolver) {
    super(
        UpgradeSettingsAction.NAME,
        transportService,
        clusterService,
        threadPool,
        UpgradeSettingsRequest::new,
        indexNameExpressionResolver
    );
    this.updateSettingsService = updateSettingsService;
}
 

/**
 * Creates a new TranslogConfig instance
 * @param shardId the shard ID this translog belongs to
 * @param translogPath the path to use for the transaction log files
 * @param indexSettings the index settings used to set internal variables
 * @param durabilty the default durability setting for the translog
 * @param bigArrays a bigArrays instance used for temporarily allocating write operations
 * @param threadPool a {@link ThreadPool} to schedule async sync durability
 */
public TranslogConfig(ShardId shardId, Path translogPath, Settings indexSettings, Translog.Durabilty durabilty, BigArrays bigArrays, @Nullable ThreadPool threadPool) {
    this.indexSettings = indexSettings;
    this.shardId = shardId;
    this.translogPath = translogPath;
    this.durabilty = durabilty;
    this.threadPool = threadPool;
    this.bigArrays = bigArrays;
    this.type = TranslogWriter.Type.fromString(indexSettings.get(INDEX_TRANSLOG_FS_TYPE, TranslogWriter.Type.BUFFERED.name()));
    this.bufferSize = (int) indexSettings.getAsBytesSize(INDEX_TRANSLOG_BUFFER_SIZE, IndexingMemoryController.INACTIVE_SHARD_TRANSLOG_BUFFER).bytes(); // Not really interesting, updated by IndexingMemoryController...

    syncInterval = indexSettings.getAsTime(INDEX_TRANSLOG_SYNC_INTERVAL, TimeValue.timeValueSeconds(5));
    if (syncInterval.millis() > 0 && threadPool != null) {
        syncOnEachOperation = false;
    } else if (syncInterval.millis() == 0) {
        syncOnEachOperation = true;
    } else {
        syncOnEachOperation = false;
    }
}
 

private void innerStart(final DiscoveryNode masterNode) {
    this.masterNode = masterNode;
    this.retryCount = 0;
    this.notifiedMasterFailure.set(false);

    // try and connect to make sure we are connected
    try {
        transportService.connectToNode(masterNode);
    } catch (final Exception e) {
        // notify master failure (which stops also) and bail..
        notifyMasterFailure(masterNode, "failed to perform initial connect [" + e.getMessage() + "]");
        return;
    }
    if (masterPinger != null) {
        masterPinger.stop();
    }
    this.masterPinger = new MasterPinger();

    // we start pinging slightly later to allow the chosen master to complete it's own master election
    threadPool.schedule(pingInterval, ThreadPool.Names.SAME, masterPinger);
}
 

@Inject
public PhasesTaskFactory(ClusterService clusterService,
                         ThreadPool threadPool,
                         JobSetup jobSetup,
                         TasksService tasksService,
                         IndicesService indicesService,
                         TransportJobAction jobAction,
                         TransportKillJobsNodeAction killJobsNodeAction) {
    this.clusterService = clusterService;
    this.jobSetup = jobSetup;
    this.tasksService = tasksService;
    this.indicesService = indicesService;
    this.jobAction = jobAction;
    this.killJobsNodeAction = killJobsNodeAction;
    this.searchExecutor = threadPool.executor(ThreadPool.Names.SEARCH);
}
 

@Inject
public TransportSearchScrollAction(Settings settings, ThreadPool threadPool, TransportService transportService,
                                   ClusterService clusterService, SearchServiceTransportAction searchService,
                                   SearchPhaseController searchPhaseController,
                                   ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, SearchScrollAction.NAME, threadPool, transportService, actionFilters, indexNameExpressionResolver,
            SearchScrollRequest.class);
    this.clusterService = clusterService;
    this.searchService = searchService;
    this.searchPhaseController = searchPhaseController;
}
 

private void performStateRecovery(boolean enforceRecoverAfterTime, String reason) {
    final Gateway.GatewayStateRecoveredListener recoveryListener = new GatewayRecoveryListener();

    if (enforceRecoverAfterTime && recoverAfterTime != null) {
        if (scheduledRecovery.compareAndSet(false, true)) {
            logger.info("delaying initial state recovery for [{}]. {}", recoverAfterTime, reason);
            threadPool.schedule(recoverAfterTime, ThreadPool.Names.GENERIC, new Runnable() {
                @Override
                public void run() {
                    if (recovered.compareAndSet(false, true)) {
                        logger.info("recover_after_time [{}] elapsed. performing state recovery...", recoverAfterTime);
                        gateway.performStateRecovery(recoveryListener);
                    }
                }
            });
        }
    } else {
        if (recovered.compareAndSet(false, true)) {
            threadPool.generic().execute(new AbstractRunnable() {
                @Override
                public void onFailure(Throwable t) {
                    logger.warn("Recovery failed", t);
                    // we reset `recovered` in the listener don't reset it here otherwise there might be a race
                    // that resets it to false while a new recover is already running?
                    recoveryListener.onFailure("state recovery failed: " + t.getMessage());
                }

                @Override
                protected void doRun() throws Exception {
                    gateway.performStateRecovery(recoveryListener);
                }
            });
        }
    }
}
 

@Inject
public TransportService(Settings settings, Transport transport, ThreadPool threadPool) {
    super(settings);
    this.transport = transport;
    this.threadPool = threadPool;
    this.tracerLogInclude = settings.getAsArray(SETTING_TRACE_LOG_INCLUDE, DEFAULT_TRACE_LOG_INCLUDE, true);
    this.tracelLogExclude = settings.getAsArray(SETTING_TRACE_LOG_EXCLUDE, DEFAULT_TRACE_LOG_EXCLUDE, true);
    tracerLog = Loggers.getLogger(logger, ".tracer");
    adapter = createAdapter();
    taskManager = createTaskManager();
}
 

@Nullable
private Scheduler.ScheduledCancellable scheduleNextRefresh(TimeValue refreshInterval) {
    if (refreshInterval.millis() > 0) {
        return threadPool.schedule(
            this,
            refreshInterval,
            ThreadPool.Names.REFRESH
        );
    }
    return null;
}
 

@Inject
public TransportPutIndexTemplateAction(TransportService transportService,
                                       ClusterService clusterService,
                                       ThreadPool threadPool,
                                       MetaDataIndexTemplateService indexTemplateService,
                                       IndexNameExpressionResolver indexNameExpressionResolver,
                                       IndexScopedSettings indexScopedSettings) {
    super(PutIndexTemplateAction.NAME, transportService, clusterService, threadPool, PutIndexTemplateRequest::new, indexNameExpressionResolver);
    this.indexTemplateService = indexTemplateService;
    this.indexScopedSettings = indexScopedSettings;
}
 

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

public boolean joinElectedMaster(DiscoveryNode masterNode) {
    if (joinMasterTask == null || joinMasterTask.isCancelled() || joinMasterTask.isDone()) {
        joinMasterTask = threadPool.schedule(TimeValue.timeValueSeconds(0), ThreadPool.Names.GENERIC, new JoinElectedMasterTask(masterNode));
    } else {
        logger.debug("there is already a running join task, not start a new one");
    }
    return true;
}
 

public static Collection<RestHandler> getHandler(Settings settings, Path configPath, RestController controller, Client client,
        AdminDNs adminDns, ConfigurationRepository cr, ClusterService cs, PrincipalExtractor principalExtractor, 
        final PrivilegesEvaluator evaluator, ThreadPool threadPool, AuditLog auditLog) {
    final List<RestHandler> handlers = new ArrayList<RestHandler>(9);
    handlers.add(new InternalUsersApiAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    handlers.add(new RolesMappingApiAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    handlers.add(new RolesApiAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    handlers.add(new ActionGroupsApiAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    handlers.add(new FlushCacheApiAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    handlers.add(new OpenDistroSecurityConfigAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    handlers.add(new PermissionsInfoAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    handlers.add(new AuthTokenProcessorAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    handlers.add(new TenantsApiAction(settings, configPath, controller, client, adminDns, cr, cs, principalExtractor, evaluator, threadPool, auditLog));
    return Collections.unmodifiableCollection(handlers);
}
 

public MonitorService(Settings settings,
                      NodeEnvironment nodeEnvironment,
                      ThreadPool threadPool,
                      ClusterInfoService clusterInfoService) {
    this.jvmGcMonitorService = new JvmGcMonitorService(settings, threadPool);
    this.osService = new OsService(settings);
    this.processService = new ProcessService(settings);
    this.jvmService = new JvmService(settings);
    this.fsService = new FsService(settings, nodeEnvironment, clusterInfoService);
}
 

@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    ThreadPool threadPool = mock(ThreadPool.class);

    ClusterService clusterService = mock(ClusterService.class);
    localNodeID = "foo";
    when(clusterService.localNode()).thenReturn(new DiscoveryNode(localNodeID, buildNewFakeTransportAddress(), Version.CURRENT));
    when(clusterService.getClusterName()).thenReturn(new ClusterName("test"));

    TransportService transportService = mock(TransportService.class);
    ActionFilters actionFilters = mock(ActionFilters.class);
    ADStateManager tarnsportStatemanager = mock(ADStateManager.class);
    ModelManager modelManager = mock(ModelManager.class);
    FeatureManager featureManager = mock(FeatureManager.class);

    action = new CronTransportAction(
        threadPool,
        clusterService,
        transportService,
        actionFilters,
        tarnsportStatemanager,
        modelManager,
        featureManager
    );
}
 

@Inject
public BulkRetryCoordinatorPool(Settings settings,
                                ClusterService clusterService,
                                ThreadPool threadPool) {
    super(settings);
    this.threadPool = threadPool;
    this.coordinatorsByShardId = new HashMap<>();
    this.coordinatorsByNodeId = new HashMap<>();
    this.clusterService = clusterService;
}
 

@Inject
public TransportUpgradeAction(Settings settings, ThreadPool threadPool, ClusterService clusterService,
                              TransportService transportService, IndicesService indicesService, ActionFilters actionFilters,
                              IndexNameExpressionResolver indexNameExpressionResolver, TransportUpgradeSettingsAction upgradeSettingsAction) {
    super(settings, UpgradeAction.NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver, UpgradeRequest.class, ThreadPool.Names.FORCE_MERGE);
    this.indicesService = indicesService;
    this.upgradeSettingsAction = upgradeSettingsAction;
}
 

@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 ClientUtil(Settings setting, Client client, Throttler throttler, ThreadPool threadPool) {
    this.requestTimeout = REQUEST_TIMEOUT.get(setting);
    this.client = client;
    this.throttler = throttler;
    this.threadPool = threadPool;
}
 

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

@Inject
public ReindexingService(final Settings settings, final Client client,
                         final ThreadPool threadPool) {
    super(settings);
    this.client = client;
    this.threadPool = threadPool;
}
 

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

@Inject
public TransportDeleteAction(Settings settings, TransportService transportService, ClusterService clusterService,
                             IndicesService indicesService, ThreadPool threadPool, ShardStateAction shardStateAction,
                             TransportCreateIndexAction createIndexAction, ActionFilters actionFilters,
                             IndexNameExpressionResolver indexNameExpressionResolver, MappingUpdatedAction mappingUpdatedAction,
                             AutoCreateIndex autoCreateIndex) {
    super(settings, DeleteAction.NAME, transportService, clusterService, indicesService, threadPool, shardStateAction,
            mappingUpdatedAction, actionFilters, indexNameExpressionResolver,
            DeleteRequest.class, DeleteRequest.class, ThreadPool.Names.INDEX);
    this.createIndexAction = createIndexAction;
    this.autoCreateIndex = autoCreateIndex;
}