Examples with ManagedExecutorServiceService org.jboss.as.ee.concurrent.service.ManagedExecutorServiceService used on opensource projects

Example 1 with ManagedExecutorServiceService

use of org.jboss.as.ee.concurrent.service.ManagedExecutorServiceService in project wildfly by wildfly.

the class ManagedExecutorServiceAdd method performRuntime.

@Override
protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException {
    final String name = context.getCurrentAddressValue();
    final String jndiName = ManagedExecutorServiceResourceDefinition.JNDI_NAME_AD.resolveModelAttribute(context, model).asString();
    final long hungTaskTerminationPeriod = ManagedExecutorServiceResourceDefinition.HUNG_TASK_TERMINATION_PERIOD_AD.resolveModelAttribute(context, model).asLong();
    final long hungTaskThreshold = ManagedExecutorServiceResourceDefinition.HUNG_TASK_THRESHOLD_AD.resolveModelAttribute(context, model).asLong();
    final boolean longRunningTasks = ManagedExecutorServiceResourceDefinition.LONG_RUNNING_TASKS_AD.resolveModelAttribute(context, model).asBoolean();
    final int coreThreads;
    final ModelNode coreThreadsModel = ManagedExecutorServiceResourceDefinition.CORE_THREADS_AD.resolveModelAttribute(context, model);
    if (coreThreadsModel.isDefined()) {
        coreThreads = coreThreadsModel.asInt();
    } else {
        coreThreads = (ProcessorInfo.availableProcessors() * 2);
    }
    final int maxThreads;
    final ModelNode maxThreadsModel = ManagedExecutorServiceResourceDefinition.MAX_THREADS_AD.resolveModelAttribute(context, model);
    if (maxThreadsModel.isDefined()) {
        maxThreads = maxThreadsModel.asInt();
    } else {
        maxThreads = coreThreads;
    }
    // Note that this must be done in the runtime stage since the core-threads value may be calculated
    if (maxThreads < coreThreads) {
        throw EeLogger.ROOT_LOGGER.invalidMaxThreads(maxThreads, coreThreads);
    }
    final long keepAliveTime = ManagedExecutorServiceResourceDefinition.KEEPALIVE_TIME_AD.resolveModelAttribute(context, model).asLong();
    final TimeUnit keepAliveTimeUnit = TimeUnit.MILLISECONDS;
    final long threadLifeTime = 0L;
    final int queueLength;
    final ModelNode queueLengthModel = ManagedExecutorServiceResourceDefinition.QUEUE_LENGTH_AD.resolveModelAttribute(context, model);
    if (queueLengthModel.isDefined()) {
        queueLength = queueLengthModel.asInt();
    } else {
        queueLength = Integer.MAX_VALUE;
    }
    final AbstractManagedExecutorService.RejectPolicy rejectPolicy = AbstractManagedExecutorService.RejectPolicy.valueOf(ManagedExecutorServiceResourceDefinition.REJECT_POLICY_AD.resolveModelAttribute(context, model).asString());
    final Integer threadPriority;
    if (model.hasDefined(ManagedExecutorServiceResourceDefinition.THREAD_PRIORITY) || !model.hasDefined(ManagedExecutorServiceResourceDefinition.THREAD_FACTORY)) {
        // defined, or use default value in case deprecated thread-factory also not defined
        threadPriority = ManagedExecutorServiceResourceDefinition.THREAD_PRIORITY_AD.resolveModelAttribute(context, model).asInt();
    } else {
        // not defined and deprecated thread-factory is defined, use it instead
        threadPriority = null;
    }
    final CapabilityServiceBuilder serviceBuilder = context.getCapabilityServiceTarget().addCapability(ManagedExecutorServiceResourceDefinition.CAPABILITY);
    final Supplier<ManagedExecutorHungTasksPeriodicTerminationService> hungTasksPeriodicTerminationService = serviceBuilder.requires(ConcurrentServiceNames.HUNG_TASK_PERIODIC_TERMINATION_SERVICE_NAME);
    final ManagedExecutorServiceService service = new ManagedExecutorServiceService(name, jndiName, hungTaskThreshold, hungTaskTerminationPeriod, longRunningTasks, coreThreads, maxThreads, keepAliveTime, keepAliveTimeUnit, threadLifeTime, queueLength, rejectPolicy, threadPriority, hungTasksPeriodicTerminationService);
    serviceBuilder.setInstance(service);
    String contextService = null;
    if (model.hasDefined(ManagedExecutorServiceResourceDefinition.CONTEXT_SERVICE)) {
        contextService = ManagedExecutorServiceResourceDefinition.CONTEXT_SERVICE_AD.resolveModelAttribute(context, model).asString();
    }
    if (contextService != null) {
        serviceBuilder.addCapabilityRequirement(ContextServiceResourceDefinition.CAPABILITY.getName(), ContextServiceImpl.class, service.getContextServiceInjector(), contextService);
    }
    String threadFactory = null;
    if (model.hasDefined(ManagedExecutorServiceResourceDefinition.THREAD_FACTORY)) {
        threadFactory = ManagedExecutorServiceResourceDefinition.THREAD_FACTORY_AD.resolveModelAttribute(context, model).asString();
    }
    if (threadFactory != null) {
        serviceBuilder.addCapabilityRequirement(ManagedThreadFactoryResourceDefinition.CAPABILITY.getName(), ManagedThreadFactoryImpl.class, service.getManagedThreadFactoryInjector(), threadFactory);
    }
    if (context.hasOptionalCapability(REQUEST_CONTROLLER_CAPABILITY_NAME, null, null)) {
        serviceBuilder.addCapabilityRequirement(REQUEST_CONTROLLER_CAPABILITY_NAME, RequestController.class, service.getRequestController());
    }
    serviceBuilder.install();
}