TrackingEventProcessorConfiguration (Axon Framework 4.4 API)

java.lang.Object
- org.axonframework.eventhandling.TrackingEventProcessorConfiguration

```
public class TrackingEventProcessorConfiguration
extends Object
```
Configuration object for the TrackingEventProcessor. The TrackingEventProcessorConfiguration provides access to the options to tweak various settings. Instances are not thread-safe and should not be altered after they have been used to initialize a TrackingEventProcessor.

Since:

3.1

Author:

Christophe Bouhier, Allard Buijze

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`TrackingEventProcessorConfiguration`	`andBatchSize(int batchSize)`
`TrackingEventProcessorConfiguration`	`andEventAvailabilityTimeout(long interval, TimeUnit unit)` Set the duration where a Tracking Processor will wait for the availability of Events, in each cycle, before extending the claim on the tokens it owns.
`TrackingEventProcessorConfiguration`	`andEventTrackerStatusChangeListener(EventTrackerStatusChangeListener eventTrackerStatusChangeListener)` Sets the `EventTrackerStatusChangeListener` which will be called on `EventTrackerStatus` changes.
`TrackingEventProcessorConfiguration`	`andInitialSegmentsCount(int segmentsSize)`
`TrackingEventProcessorConfiguration`	`andInitialTrackingToken(Function<StreamableMessageSource<TrackedEventMessage<?>>,TrackingToken> initialTrackingTokenBuilder)` Sets the Builder to use to create the initial tracking token.
`TrackingEventProcessorConfiguration`	`andThreadFactory(Function<String,ThreadFactory> threadFactory)` Sets the ThreadFactory to use to create the threads to process events on.
`TrackingEventProcessorConfiguration`	`andTokenClaimInterval(long tokenClaimInterval, TimeUnit timeUnit)` Sets the time to wait after a failed attempt to claim any token, before making another attempt.
`static TrackingEventProcessorConfiguration`	`forParallelProcessing(int threadCount)` Initialize a configuration instance with the given `threadCount`.
`static TrackingEventProcessorConfiguration`	`forSingleThreadedProcessing()` Initialize a configuration with single threaded processing.
`int`	`getBatchSize()`
`int`	`getEventAvailabilityTimeout()`
`EventTrackerStatusChangeListener`	`getEventTrackerStatusChangeListener()` Returns the `EventTrackerStatusChangeListener` defined in this configuration, to be called whenever an `EventTrackerStatus` change occurs.
`int`	`getInitialSegmentsCount()`
`Function<StreamableMessageSource<TrackedEventMessage<?>>,TrackingToken>`	`getInitialTrackingToken()`
`int`	`getMaxThreadCount()`
`ThreadFactory`	`getThreadFactory(String processorName)` Provides the ThreadFactory to use to construct Threads for the processor with given `processorName`
`long`	`getTokenClaimInterval()` Returns the time, in milliseconds, the processor should wait after a failed attempt to claim any segments for processing.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - forSingleThreadedProcessing
```
public static TrackingEventProcessorConfiguration forSingleThreadedProcessing()
```
    Initialize a configuration with single threaded processing.
    
    Returns:
    
    a Configuration prepared for single threaded processing
  - forParallelProcessing
```
public static TrackingEventProcessorConfiguration forParallelProcessing(int threadCount)
```
    Initialize a configuration instance with the given threadCount. This is both the number of threads that a processor will start for processing, as well as the initial number of segments that will be created when the processor is first started.
    
    Parameters:
    
    threadCount - the number of segments to process in parallel
    
    Returns:
    
    a newly created configuration
  - andBatchSize
```
public TrackingEventProcessorConfiguration andBatchSize(int batchSize)
```
    Parameters:
    
    batchSize - The maximum number of events to process in a single batch.
    
    Returns:
    
    this for method chaining
  - andInitialSegmentsCount
```
public TrackingEventProcessorConfiguration andInitialSegmentsCount(int segmentsSize)
```
    Parameters:
    
    segmentsSize - The number of segments requested for handling asynchronous processing of events.
    
    Returns:
    
    this for method chaining
  - andThreadFactory
```
public TrackingEventProcessorConfiguration andThreadFactory(Function<String,ThreadFactory> threadFactory)
```
    Sets the ThreadFactory to use to create the threads to process events on. Each Segment will be processed by a separate thread.
    
    Parameters:
    
    threadFactory - The factory to create threads with
    
    Returns:
    
    this for method chaining
  - andEventAvailabilityTimeout
```
public TrackingEventProcessorConfiguration andEventAvailabilityTimeout(long interval,
                                                                       TimeUnit unit)
```
    Set the duration where a Tracking Processor will wait for the availability of Events, in each cycle, before extending the claim on the tokens it owns.
    Note that some storage engines for the EmbeddedEventStore do not support streaming. They may poll for messages once on an BlockingStream.hasNextAvailable(int, TimeUnit) invocation, and wait for the timeout to occur.
    This value should be significantly shorter than the claim timeout configured on the Token Store. Failure to do so may cause claims to be stolen while a tread is waiting for events. Also, with very long timeouts, it will take longer for threads to pick up the instructions they need to process.
    Defaults to 1 second.
    The given value must be strictly larger than 0, and may not exceed Integer.MAX_VALUE milliseconds.
    
    Parameters:
    
    interval - The interval in which claims on segments need to be extended
    
    unit - The unit in which the interval is expressed
    
    Returns:
    
    this for method chaining
  - andInitialTrackingToken
```
public TrackingEventProcessorConfiguration andInitialTrackingToken(Function<StreamableMessageSource<TrackedEventMessage<?>>,TrackingToken> initialTrackingTokenBuilder)
```
    Sets the Builder to use to create the initial tracking token. This token is used by the processor as a starting point.
    
    Parameters:
    
    initialTrackingTokenBuilder - The Builder of initial tracking token
    
    Returns:
    
    this for method chaining
  - andTokenClaimInterval
```
public TrackingEventProcessorConfiguration andTokenClaimInterval(long tokenClaimInterval,
                                                                 TimeUnit timeUnit)
```
    Sets the time to wait after a failed attempt to claim any token, before making another attempt.
    
    Parameters:
    
    tokenClaimInterval - The time to wait in between attempts to claim a token
    
    timeUnit - The unit of time
    
    Returns:
    
    this for method chaining
  - andEventTrackerStatusChangeListener
```
public TrackingEventProcessorConfiguration andEventTrackerStatusChangeListener(EventTrackerStatusChangeListener eventTrackerStatusChangeListener)
```
    Sets the EventTrackerStatusChangeListener which will be called on EventTrackerStatus changes. Defaults to EventTrackerStatusChangeListener.noOp().
    
    Parameters:
    
    eventTrackerStatusChangeListener - the EventTrackerStatusChangeListener to use
    
    Returns:
    
    this for method chaining
  - getBatchSize
```
public int getBatchSize()
```
    Returns:
    
    the maximum number of events to process in a single batch.
  - getInitialSegmentsCount
```
public int getInitialSegmentsCount()
```
    Returns:
    
    the number of segments requested for handling asynchronous processing of events.
  - getInitialTrackingToken
```
public Function<StreamableMessageSource<TrackedEventMessage<?>>,TrackingToken> getInitialTrackingToken()
```
    Returns:
    
    the Builder of initial tracking token
  - getMaxThreadCount
```
public int getMaxThreadCount()
```
    Returns:
    
    the pool size of core threads as per ThreadPoolExecutor.getCorePoolSize()
  - getEventAvailabilityTimeout
```
public int getEventAvailabilityTimeout()
```
    Returns:
    
    the time, in milliseconds, that a processor should wait for available events before going into a cycle of updating claims and checking for incoming instructions.
  - getThreadFactory
```
public ThreadFactory getThreadFactory(String processorName)
```
    Provides the ThreadFactory to use to construct Threads for the processor with given processorName
    
    Parameters:
    
    processorName - The name of the processor for which to return the ThreadFactory
    
    Returns:
    
    the thread factory configured
  - getTokenClaimInterval
```
public long getTokenClaimInterval()
```
    Returns the time, in milliseconds, the processor should wait after a failed attempt to claim any segments for processing. Generally, this means all segments are claimed.
    
    Returns:
    
    the time, in milliseconds, to wait in between attempts to claim a token
    
    See Also:
    
    andTokenClaimInterval(long, TimeUnit)
  - getEventTrackerStatusChangeListener
```
public EventTrackerStatusChangeListener getEventTrackerStatusChangeListener()
```
    Returns the EventTrackerStatusChangeListener defined in this configuration, to be called whenever an EventTrackerStatus change occurs.
    
    Returns:
    
    the EventTrackerStatusChangeListener defined in this configuration

Class TrackingEventProcessorConfiguration

Method Summary

Methods inherited from class java.lang.Object

Method Detail

forSingleThreadedProcessing

forParallelProcessing

andBatchSize

andInitialSegmentsCount

andThreadFactory

andEventAvailabilityTimeout

andInitialTrackingToken

andTokenClaimInterval

andEventTrackerStatusChangeListener

getBatchSize

getInitialSegmentsCount

getInitialTrackingToken

getMaxThreadCount

getEventAvailabilityTimeout

getThreadFactory

getTokenClaimInterval

getEventTrackerStatusChangeListener