Package org.bonitasoft.engine.connector.impl

Class ConnectorExecutorImpl

java.lang.Object

org.bonitasoft.engine.connector.impl.ConnectorExecutorImpl

All Implemented Interfaces:

LifecycleService, TenantLifecycleService, ConnectorExecutor

public class ConnectorExecutorImpl
extends java.lang.Object
implements ConnectorExecutor

Execute connectors directly

Author:

Baptiste Mesta, Celine Souchet, Matthieu Chaffotte

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	ConnectorExecutorImpl.ExecuteConnectorCallable

Field Summary

Fields

Modifier and Type	Field	Description
static java.lang.String	NUMBER_OF_CONNECTORS_EXECUTED
static java.lang.String	NUMBER_OF_CONNECTORS_PENDING
static java.lang.String	NUMBER_OF_CONNECTORS_RUNNING

Constructor Summary

Constructors

Constructor	Description
ConnectorExecutorImpl(int queueCapacity, int corePoolSize, int maximumPoolSize, long keepAliveTimeSeconds, SessionAccessor sessionAccessor, SessionService sessionService, TimeTracker timeTracker, io.micrometer.core.instrument.MeterRegistry meterRegistry, long tenantId, ExecutorServiceMetricsProvider executorServiceMetricsProvider)	The handling of threads relies on the JVM The rules to create new thread are: - If the number of threads is less than the corePoolSize, create a new Thread to run a new task.

Method Summary

Modifier and Type	Method	Description
void	disconnect(SConnector sConnector)	call disconnect method of the connector
java.util.concurrent.CompletableFuture<ConnectorExecutionResult>	execute(SConnector sConnector, java.util.Map<java.lang.String,java.lang.Object> inputParameters, java.lang.ClassLoader classLoader)	Executes a connector.
protected java.util.concurrent.CompletableFuture<ConnectorExecutionResult>	execute(SConnector sConnector, InterruptibleCallable<java.util.Map<java.lang.String,java.lang.Object>> task)
void	pause()	Temporary halt the execution of this service.
void	resume()	resume the execution the service
void	start()	Start the service
void	stop()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.bonitasoft.engine.commons.TenantLifecycleService

init

Field Detail

NUMBER_OF_CONNECTORS_PENDING

public static final java.lang.String NUMBER_OF_CONNECTORS_PENDING

See Also:

Constant Field Values

NUMBER_OF_CONNECTORS_RUNNING

public static final java.lang.String NUMBER_OF_CONNECTORS_RUNNING

See Also:

Constant Field Values

NUMBER_OF_CONNECTORS_EXECUTED

public static final java.lang.String NUMBER_OF_CONNECTORS_EXECUTED

See Also:

Constant Field Values

Constructor Detail

ConnectorExecutorImpl

public ConnectorExecutorImpl(int queueCapacity,
                             int corePoolSize,
                             int maximumPoolSize,
                             long keepAliveTimeSeconds,
                             SessionAccessor sessionAccessor,
                             SessionService sessionService,
                             TimeTracker timeTracker,
                             io.micrometer.core.instrument.MeterRegistry meterRegistry,
                             long tenantId,
                             ExecutorServiceMetricsProvider executorServiceMetricsProvider)

The handling of threads relies on the JVM The rules to create new thread are: - If the number of threads is less than the corePoolSize, create a new Thread to run a new task. - If the number of threads is equal (or greater than) the corePoolSize, put the task into the queue. - If the queue is full, and the number of threads is less than the maxPoolSize, create a new thread to run tasks in. - If the queue is full, and the number of threads is greater than or equal to maxPoolSize, reject the task.

Parameters:

queueCapacity - The maximum number of execution of connector to queue for each thread

corePoolSize - the number of threads to keep in the pool, even if they are idle, unless allowCoreThreadTimeOut is set

maximumPoolSize - the maximum number of threads to allow in the pool

keepAliveTimeSeconds - when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating. (in seconds)

Method Detail

execute

public java.util.concurrent.CompletableFuture<ConnectorExecutionResult> execute(SConnector sConnector,
                                                                                java.util.Map<java.lang.String,java.lang.Object> inputParameters,
                                                                                java.lang.ClassLoader classLoader)
                                                                         throws SConnectorException

Description copied from interface: ConnectorExecutor

Executes a connector.

Specified by:

execute in interface ConnectorExecutor

Parameters:

sConnector - The connector will be executed

inputParameters - The input parameters of connector

classLoader - The classLoader within the connector will be executed

Returns:

a completable future with the result

Throws:

SConnectorException - Error thrown when error occurs in connector executing

execute

protected java.util.concurrent.CompletableFuture<ConnectorExecutionResult> execute(SConnector sConnector,
                                                                                   InterruptibleCallable<java.util.Map<java.lang.String,java.lang.Object>> task)

disconnect

public void disconnect(SConnector sConnector)
                throws SConnectorException

Description copied from interface: ConnectorExecutor

call disconnect method of the connector

Specified by:

disconnect in interface ConnectorExecutor

Throws:

SConnectorException

start

public void start()

Description copied from interface: LifecycleService

Start the service

Specified by:

start in interface LifecycleService

stop

public void stop()

Specified by:

stop in interface LifecycleService

pause

public void pause()

Description copied from interface: LifecycleService

Temporary halt the execution of this service.

Specified by:

pause in interface LifecycleService

resume

public void resume()

Description copied from interface: LifecycleService

resume the execution the service

Specified by:

resume in interface LifecycleService