DatabaseSystemEventNodeImpl (broadleaf-jobs-events 3.2.0-GA API)

java.lang.Object
- com.broadleafcommerce.jobsevents.service.DatabaseSystemEventNodeImpl

All Implemented Interfaces:: DatabaseSystemEventNode, org.springframework.beans.factory.Aware, org.springframework.context.ApplicationContextAware, org.springframework.context.Lifecycle, org.springframework.context.Phased, org.springframework.context.SmartLifecycle

@Service(value="blDatabaseSystemEventNode")
 @ManagedResource(objectName="org.broadleafcommerce:name=DatabaseSystemEventNode",
                 description="Database System Event Node",
                 currencyTimeLimit=15)
public class DatabaseSystemEventNodeImpl
extends Object
implements DatabaseSystemEventNode, org.springframework.context.ApplicationContextAware, org.springframework.context.SmartLifecycle

Author:: Jeff Fischer

Field Summary

Fields
Modifier and Type	Field and Description
`protected CacheInvalidationHelper`	`cacheInvalidationHelper`
`protected ConsumeWorker`	`consumeWorker`
`protected org.springframework.context.ApplicationContext`	`context`
`protected ConsumeWorker`	`durableConsumeWorker`
`protected int`	`durableEventsPerPoll` Deprecated. Not used internally
`protected org.quartz.Scheduler`	`durableScheduler`
`protected Map<String,List<SystemEventConsumer>>`	`eventConsumers`
`protected boolean`	`eventConsumptionEnabled` Whether or not the schedulers for event consumption are intialized at startup.
`protected EventLockUtil`	`eventLockUtil`
`protected int`	`eventNodeLogInterval` The interval for DEBUG level logging in this class.
`protected int`	`eventsPerPoll` The number of `EventScopeType.VM` events to retrieve from the datastore and queue up for consumption during a polling attempt (see `pollingIntervalSeconds`).
`protected EventWorkerType`	`eventWorkerType`
`protected ConsumeWorker`	`globalConsumeWorker`
`protected int`	`globalEventsPerPoll` The number of `EventScopeType.GLOBAL` events to retrieve from the datastore and queue up for consumption during a polling attempt (`globalPollingIntervalSeconds`).
`protected long`	`globalJobThreadPoolCount` The quantity of threads use to consume `EventScopeType.GLOBAL` events.
`protected long`	`globalPollingIntervalSeconds` Period of time between attempts to retrieve a new batch of `EventScopeType.GLOBAL` events from the database.
`protected org.quartz.Scheduler`	`globalScheduler`
`protected long`	`jobThreadPoolCount` The quantity of threads used to consume `EventScopeType.VM` events.
`protected org.quartz.Scheduler`	`keepAliveScheduler`
`protected ConsumeWorker`	`keepAliveWorker`
`protected long`	`missedDurableEventsPollingThresholdSeconds` The maximum age of a durable events (in seconds) that a node will consume.
`protected boolean`	`pause`
`protected long`	`pollingIntervalSeconds` Period of time between attempts to retrieve a new batch of `EventScopeType.VM` events from the database.
`protected ConsumeWorker`	`priorityConsumeWorker`
`protected int`	`priorityEventsPerPoll` The number of priority events to retrieve from the datastore and queue up for consumption during a polling attempt (`priorityPollingIntervalSeconds`).
`protected long`	`priorityJobThreadPoolCount` The quantity of threads used to consume priority events.
`protected long`	`priorityPollingIntervalSeconds` Period of time between attempts to retrieve a new batch of priority events from the database.
`protected org.quartz.Scheduler`	`priorityScheduler`
`protected ProcessMonitorStatusManager`	`processMonitorStatusManager`
`protected ProcessStatusManager`	`processStatusManager`
`protected org.quartz.Scheduler`	`scheduler`
`protected SystemEventCompressionHelper`	`systemEventCompressionHelper`
`protected DatabaseSystemEventDao`	`systemEventDao`
`protected SystemEventSender`	`systemEventSender`
`protected org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor`	`taskExecutor`
`protected List<ScheduledJobThreadInitializer>`	`threadInitializers`
`protected org.broadleafcommerce.common.util.StreamingTransactionCapableUtil`	`transUtil`
`protected List<SystemEventConsumer>`	`unsortedConsumers`

Fields inherited from interface org.springframework.context.SmartLifecycle
DEFAULT_PHASE

Constructor Summary

Constructors
Constructor and Description

DatabaseSystemEventNodeImpl()

Constructors
Constructor and Description
`DatabaseSystemEventNodeImpl()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`asyncExecuteEvent(boolean durable, QueueStatusThreadPoolTaskExecutor executor, Map<String,List<SystemEventConsumer>> consumers, SystemEvent event)`
`protected void`	`buildEventScheduler()`
`protected void`	`clearLog()`
`void`	`consumeLocalEvent(SystemEvent event)` Cause asynchronous consumption of this event to occur in the same JVM, rather than provide to event to the cluster.
`EventWorkerType`	`determineHostWorkerType()` Determine if this is an ADMIN or SITE node
`protected void`	`executeEvent(SystemEventConsumer consumer, SystemEvent lockedEvent)`
`void`	`executeEvents(List<SystemEvent> events, boolean durable, QueueStatusThreadPoolTaskExecutor executor)` Iterate through a list of events and provide those events to the appropriate `SystemEventConsumer` instances.
`int`	`getDurableEventsPerPoll()` The number of events of type DURABLE_GLOBAL to retrieve in each poll.
`Map<String,List<SystemEventConsumer>>`	`getEventConsumers()` All the `SystemEventConsumer` instances registered in Spring.
`int`	`getEventsPerPoll()` The number of `EventScopeType.VM` events to retrieve in each poll.
`int`	`getGlobalEventsPerPoll()` The number of `EventScopeType.GLOBAL` events to retrieve in each poll.
`long`	`getGlobalJobThreadPoolCount()` The number of threads actively polling for available `EventScopeType.GLOBAL` events.
`long`	`getGlobalPollingIntervalSeconds()`
`protected String`	`getHostIpAddress()` Retrieve the ip address for the current host.
`long`	`getJobThreadPoolCount()` The number of threads actively polling for available `EventScopeType.VM` events.
`long`	`getMissedDurableEventsPollingThresholdSeconds()` The maximum amount of time into the past that durable events should be retrieved.
`String`	`getNodeId()`
`RegisteredNode`	`getNodeRegistration()` Get the `RegisteredNode` associated.
`int`	`getPhase()`
`long`	`getPollingIntervalSeconds()` The wait time between each polling attempt for available events.
`int`	`getPriorityEventsPerPoll()` The number of priority events to retrieve in each poll.
`long`	`getPriorityJobThreadPoolCount()` The number of threads actively polling for priority events (`EventScopeType.VM` or `EventScopeType.GLOBAL`).
`long`	`getPriorityPollingIntervalSeconds()`
`DatabaseSystemEventDao`	`getSystemEventDao()`
`protected void`	`incrementLog()`
`void`	`invalidateCacheElement(String entityClass, String id)`
`void`	`invalidateCacheElement(String entityClass, String property, String id)` Utility method for initiating a cache invalidation event.
`void`	`invalidateCacheRegion(String region)`
`boolean`	`isAutoStartup()`
`boolean`	`isCreated()`
`protected boolean`	`isDebugEnabled()`
`protected boolean`	`isDebugEnabled(boolean checkInterval)`
`protected boolean`	`isLogEnabled(int intervalCount)`
`boolean`	`isPause()` Whether or not this node is paused.
`boolean`	`isRunning()`
`protected void`	`removeUniversalDuplicates(List<SystemEvent> events)`
`void`	`setApplicationContext(org.springframework.context.ApplicationContext applicationContext)`
`void`	`setDurableEventsPerPoll(int durableEventsPerPoll)`
`void`	`setEventConsumers(Map<String,List<SystemEventConsumer>> eventConsumers)`
`void`	`setEventsPerPoll(int eventsPerPoll)`
`void`	`setGlobalEventsPerPoll(int globalEventsPerPoll)`
`void`	`setGlobalJobThreadPoolCount(long globalJobThreadPoolCount)`
`void`	`setGlobalPollingIntervalSeconds(long globalPollingIntervalSeconds)`
`void`	`setJobThreadPoolCount(long jobThreadPoolCount)`
`void`	`setMissedDurableEventsPollingThresholdSeconds(long missedDurableEventsPollingThresholdSeconds)`
`void`	`setPause(boolean pause)`
`void`	`setPollingIntervalSeconds(long pollingIntervalSeconds)`
`void`	`setPriorityEventsPerPoll(int priorityEventsPerPoll)`
`void`	`setPriorityJobThreadPoolCount(long priorityJobThreadPoolCount)`
`void`	`setPriorityPollingIntervalSeconds(long priorityPollingIntervalSeconds)`
`void`	`start()`
`void`	`stop()`
`void`	`stop(Runnable callback)`

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

- Field Detail
  - pollingIntervalSeconds
```
@Value(value="${database.event.polling.interval.seconds:5}")
protected long pollingIntervalSeconds
```
    Period of time between attempts to retrieve a new batch of EventScopeType.VM events from the database. If the last batch of events has not been depleted yet by the configured worker threads (see jobThreadPoolCount) at the time of polling, the current polling round is skipped.
    Default is 5. Can be set via property ${database.event.polling.interval.seconds}.
    
    See Also:
    
    ConsumeWorkerImpl
  - eventsPerPoll
```
@Value(value="${database.event.quantity.per.poll:5}")
protected int eventsPerPoll
```
    The number of EventScopeType.VM events to retrieve from the datastore and queue up for consumption during a polling attempt (see pollingIntervalSeconds).
    Default is 5. Can be set via property ${database.event.quantity.per.poll}.
    
    See Also:
    
    ConsumeWorkerImpl
  - priorityPollingIntervalSeconds
```
@Value(value="${database.priority.event.polling.interval.seconds:5}")
protected long priorityPollingIntervalSeconds
```
    Period of time between attempts to retrieve a new batch of priority events from the database. If the last batch of events has not been depleted yet by the configured worker threads (see priorityJobThreadPoolCount) at the time of polling, the current polling round is skipped. See PriorityConsumeWorkerImpl for more information on priority events.
    Default is 5. Can be set via property ${database.priority.event.polling.interval.seconds}.
    
    See Also:
    
    PriorityConsumeWorkerImpl
  - priorityEventsPerPoll
```
@Value(value="${database.priority.event.quantity.per.poll:20}")
protected int priorityEventsPerPoll
```
    The number of priority events to retrieve from the datastore and queue up for consumption during a polling attempt (priorityPollingIntervalSeconds). See PriorityConsumeWorkerImpl for more information on priority events.
    Default is 20. Can be set via property ${database.priority.event.quantity.per.poll}.
    
    See Also:
    
    PriorityConsumeWorkerImpl
  - globalPollingIntervalSeconds
```
@Value(value="${database.global.event.polling.interval.seconds:5}")
protected long globalPollingIntervalSeconds
```
    Period of time between attempts to retrieve a new batch of EventScopeType.GLOBAL events from the database. If the last batch of events has not been depleted yet by the configured worker threads (see globalJobThreadPoolCount) at the time of polling, the current polling round is skipped. See GlobalConsumeWorkerImpl for more information.
    Default is 5. Can be set via property ${database.global.event.polling.interval.seconds}.
    
    See Also:
    
    GlobalConsumeWorkerImpl
  - globalEventsPerPoll
```
@Value(value="${database.global.event.quantity.per.poll:10}")
protected int globalEventsPerPoll
```
    The number of EventScopeType.GLOBAL events to retrieve from the datastore and queue up for consumption during a polling attempt (globalPollingIntervalSeconds). See GlobalConsumeWorkerImpl for more information.
    Default is 10. Can be set via property ${database.global.event.quantity.per.poll}.
    
    See Also:
    
    GlobalConsumeWorkerImpl
  - durableEventsPerPoll
```
@Deprecated
 @Value(value="${database.durable.event.quantity.per.poll:250}")
protected int durableEventsPerPoll
```
    Deprecated. Not used internally
  - missedDurableEventsPollingThresholdSeconds
```
@Value(value="${database.missed.durable.event.polling.threshold.seconds:604800}")
protected long missedDurableEventsPollingThresholdSeconds
```
    The maximum age of a durable events (in seconds) that a node will consume. A value of -1 means there is no max age and all available missed durable events will be processed.
    604800 is the default (7 days). Can be set via property ${database.missed.durable.event.polling.threshold.seconds}.
  - eventConsumptionEnabled
```
@Value(value="${database.event.consumption.enabled:true}")
protected boolean eventConsumptionEnabled
```
    Whether or not the schedulers for event consumption are intialized at startup. When false, new SystemEvents will not be consumed.
    Default is true. Can be set via property ${database.event.consumption.enabled}.
  - eventNodeLogInterval
```
@Value(value="${database.event.node.log.interval:-1}")
protected int eventNodeLogInterval
```
    The interval for DEBUG level logging in this class. If set to -1, DEBUG logging will always be emitted when the log level is set to DEBUG. However, if the interval is set to a positive integer, the DEBUG logging will be emitted (if the log level is set to DEBUG) every [interval] times a batch of events is passed into this class for processing.
    Default is -1. Can be set via property ${database.event.node.log.interval}.
  - jobThreadPoolCount
```
@Value(value="${database.job.thread.pool.count:2}")
protected long jobThreadPoolCount
```
    The quantity of threads used to consume EventScopeType.VM events. This can be increased to increase potential throughput via multiple, concurrent threads consuming events, at the possible cost of additional CPU usage. Since consuming events is often not the primary work of a given node in the cluster, it is important to throttle event consumption appropriately to not interfere with the nodes primary purpose.
    The default is 2. Can be set via property ${database.job.thread.pool.count}.
    See eventsPerPoll and pollingIntervalSeconds for other properties that can be used to affect throughput, possibly without changing the job thread pool count.
  - priorityJobThreadPoolCount
```
@Value(value="${database.priority.job.thread.pool.count:4}")
protected long priorityJobThreadPoolCount
```
    The quantity of threads used to consume priority events. Priority events are those whose SystemEvent.getPriority() value is less than 0.
    This property can be increased to increase potential throughput via multiple, concurrent threads consuming events, at the possible cost of additional CPU usage. Since consuming events is often not the primary work of a given node in the cluster, it is important to throttle event consumption appropriately to not interfere with the nodes primary purpose.
    The default is 4. Can be set via property ${database.priority.job.thread.pool.count}.
    See priorityEventsPerPoll and priorityPollingIntervalSeconds for other properties that can be used to affect throughput, possibly without changing the job thread pool count.
  - globalJobThreadPoolCount
```
@Value(value="${database.global.job.thread.pool.count:3}")
protected long globalJobThreadPoolCount
```
    The quantity of threads use to consume EventScopeType.GLOBAL events. This can be increased to increase potential throughput via multiple, concurrent threads consuming events, at the possible cost of additional CPU usage. Since consuming events is often not the primary work of a given node in the cluster, it is important to throttle event consumption appropriately to not interfere with the nodes primary purpose.
    The default is 3. Can be set via property ${database.global.job.thread.pool.count}.
    See eventsPerPoll and pollingIntervalSeconds for other properties that can be used to affect throughput, possibly without changing the job thread pool count.
  - transUtil
```
protected org.broadleafcommerce.common.util.StreamingTransactionCapableUtil transUtil
```
  - systemEventDao
```
protected DatabaseSystemEventDao systemEventDao
```
  - processStatusManager
```
protected ProcessStatusManager processStatusManager
```
  - systemEventCompressionHelper
```
protected SystemEventCompressionHelper systemEventCompressionHelper
```
  - processMonitorStatusManager
```
protected ProcessMonitorStatusManager processMonitorStatusManager
```
  - consumeWorker
```
protected ConsumeWorker consumeWorker
```
  - priorityConsumeWorker
```
protected ConsumeWorker priorityConsumeWorker
```
  - globalConsumeWorker
```
protected ConsumeWorker globalConsumeWorker
```
  - durableConsumeWorker
```
protected ConsumeWorker durableConsumeWorker
```
  - keepAliveWorker
```
protected ConsumeWorker keepAliveWorker
```
  - systemEventSender
```
protected SystemEventSender systemEventSender
```
  - cacheInvalidationHelper
```
protected CacheInvalidationHelper cacheInvalidationHelper
```
  - taskExecutor
```
protected org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor taskExecutor
```
  - eventLockUtil
```
protected EventLockUtil eventLockUtil
```
  - threadInitializers
```
protected List<ScheduledJobThreadInitializer> threadInitializers
```
  - unsortedConsumers
```
protected List<SystemEventConsumer> unsortedConsumers
```
  - eventConsumers
```
protected Map<String,List<SystemEventConsumer>> eventConsumers
```
  - scheduler
```
protected org.quartz.Scheduler scheduler
```
  - priorityScheduler
```
protected org.quartz.Scheduler priorityScheduler
```
  - globalScheduler
```
protected org.quartz.Scheduler globalScheduler
```
  - durableScheduler
```
protected org.quartz.Scheduler durableScheduler
```
  - keepAliveScheduler
```
protected org.quartz.Scheduler keepAliveScheduler
```
  - pause
```
protected boolean pause
```
  - eventWorkerType
```
protected EventWorkerType eventWorkerType
```
  - context
```
protected org.springframework.context.ApplicationContext context
```
- Constructor Detail
  - DatabaseSystemEventNodeImpl
```
public DatabaseSystemEventNodeImpl()
```
- Method Detail
  - isAutoStartup
```
public boolean isAutoStartup()
```
    Specified by:
    
    isAutoStartup in interface org.springframework.context.SmartLifecycle
  - stop
```
public void stop(Runnable callback)
```
    Specified by:
    
    stop in interface org.springframework.context.SmartLifecycle
  - start
```
public void start()
```
    Specified by:
    
    start in interface org.springframework.context.Lifecycle
  - isRunning
```
public boolean isRunning()
```
    Specified by:
    
    isRunning in interface org.springframework.context.Lifecycle
  - getPhase
```
public int getPhase()
```
    Specified by:
    
    getPhase in interface org.springframework.context.Phased
    
    Specified by:
    
    getPhase in interface org.springframework.context.SmartLifecycle
  - consumeLocalEvent
```
public void consumeLocalEvent(SystemEvent event)
```
    Description copied from interface: DatabaseSystemEventNode
    
    Cause asynchronous consumption of this event to occur in the same JVM, rather than provide to event to the cluster. This avenue also avoids persistence of the event in the database.
    
    Specified by:
    
    consumeLocalEvent in interface DatabaseSystemEventNode
  - stop
```
public void stop()
```
    Specified by:
    
    stop in interface org.springframework.context.Lifecycle
  - setApplicationContext
```
public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext)
                           throws org.springframework.beans.BeansException
```
    Specified by:
    
    setApplicationContext in interface org.springframework.context.ApplicationContextAware
    
    Throws:
    
    org.springframework.beans.BeansException
  - determineHostWorkerType
```
public EventWorkerType determineHostWorkerType()
```
    Description copied from interface: DatabaseSystemEventNode
    
    Determine if this is an ADMIN or SITE node
    
    Specified by:
    
    determineHostWorkerType in interface DatabaseSystemEventNode
    
    Returns:
  - executeEvents
```
public void executeEvents(List<SystemEvent> events,
                          boolean durable,
                          QueueStatusThreadPoolTaskExecutor executor)
```
    Description copied from interface: DatabaseSystemEventNode
    
    Iterate through a list of events and provide those events to the appropriate SystemEventConsumer instances.
    
    Specified by:
    
    executeEvents in interface DatabaseSystemEventNode
    
    durable - Whether or not these events are durable (i.e. GLOBAL_DURABLE)
  - getNodeRegistration
```
public RegisteredNode getNodeRegistration()
```
    Description copied from interface: DatabaseSystemEventNode
    
    Get the RegisteredNode associated. Every instance of DatabaseSystemEventNode creates a registration in the database.
    
    Specified by:
    
    getNodeRegistration in interface DatabaseSystemEventNode
    
    Returns:
  - isPause
```
@ManagedAttribute(description="Whether or not event processing is currently paused.",
                  currencyTimeLimit=15)
public boolean isPause()
```
    Description copied from interface: DatabaseSystemEventNode
    
    Whether or not this node is paused. Paused nodes still participate in heartbeat checks, but do not actively consume events.
    
    Specified by:
    
    isPause in interface DatabaseSystemEventNode
    
    Returns:
  - setPause
```
@ManagedAttribute(description="Whether or not event processing is currently paused.",
                  currencyTimeLimit=15)
public void setPause(boolean pause)
```
    Specified by:
    
    setPause in interface DatabaseSystemEventNode
  - invalidateCacheElement
```
@ManagedOperation(description="Invalidate the cache for an entity collection property",
                  currencyTimeLimit=15)
public void invalidateCacheElement(String entityClass,
                                                                                                                                                                   String property,
                                                                                                                                                                   String id)
```
    Description copied from interface: DatabaseSystemEventNode
    
    Utility method for initiating a cache invalidation event.
    
    Specified by:
    
    invalidateCacheElement in interface DatabaseSystemEventNode
  - invalidateCacheElement
```
@ManagedOperation(description="Invalidate the cache for an entity",
                  currencyTimeLimit=15)
public void invalidateCacheElement(String entityClass,
                                                                                                                                               String id)
```
    Specified by:
    
    invalidateCacheElement in interface DatabaseSystemEventNode
  - invalidateCacheRegion
```
@ManagedOperation(description="Invalidate an entire cache region",
                  currencyTimeLimit=15)
public void invalidateCacheRegion(String region)
```
    Specified by:
    
    invalidateCacheRegion in interface DatabaseSystemEventNode
  - getSystemEventDao
```
public DatabaseSystemEventDao getSystemEventDao()
```
    Specified by:
    
    getSystemEventDao in interface DatabaseSystemEventNode
  - getPollingIntervalSeconds
```
public long getPollingIntervalSeconds()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The wait time between each polling attempt for available events. This value can be decreased for quicker event consumption response times at the cost of increased database traffic. Defaults to 5.
    
    Specified by:
    
    getPollingIntervalSeconds in interface DatabaseSystemEventNode
    
    Returns:
  - setPollingIntervalSeconds
```
public void setPollingIntervalSeconds(long pollingIntervalSeconds)
```
    Specified by:
    
    setPollingIntervalSeconds in interface DatabaseSystemEventNode
  - getPriorityPollingIntervalSeconds
```
public long getPriorityPollingIntervalSeconds()
```
  - setPriorityPollingIntervalSeconds
```
public void setPriorityPollingIntervalSeconds(long priorityPollingIntervalSeconds)
```
  - getGlobalPollingIntervalSeconds
```
public long getGlobalPollingIntervalSeconds()
```
  - setGlobalPollingIntervalSeconds
```
public void setGlobalPollingIntervalSeconds(long globalPollingIntervalSeconds)
```
  - getEventsPerPoll
```
public int getEventsPerPoll()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The number of EventScopeType.VM events to retrieve in each poll. This can be increased to process more events at any given time at the cost of prolonged CPU consumption. It is likely advantageous to throttle event consumption to avoid overly taxing the system and penalizing other operations. Also, smaller event processing groups allows the system to respond more quickly to events that utilize the priority feature (see SystemEvent.getPriority(). The default value is 5. This does not include events of type GLOBAL_DURABLE.
    See the discussion on DatabaseSystemEventNode.getPriorityEventsPerPoll() for similar configuration related to special priority events.
    
    Specified by:
    
    getEventsPerPoll in interface DatabaseSystemEventNode
    
    Returns:
  - setEventsPerPoll
```
public void setEventsPerPoll(int eventsPerPoll)
```
    Specified by:
    
    setEventsPerPoll in interface DatabaseSystemEventNode
  - getPriorityEventsPerPoll
```
public int getPriorityEventsPerPoll()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The number of priority events to retrieve in each poll. Priority events have SystemEvent.getPriority() less than zero. Priority events are generally considered to be important functional events that consume very quickly (e.g. cache invalidations). Processing these events in their own queue attempts to guarantee a more timely processing, instead of having them queue up with standard, possibly long-running, events in the standard queue.
    The priority events per poll can be increased to process more events at any given time at the cost of prolonged CPU consumption. It is likely advantageous to throttle event consumption to avoid overly taxing the system and penalizing other operations. The default value is 5. This does not include events of type GLOBAL_DURABLE.
    
    Specified by:
    
    getPriorityEventsPerPoll in interface DatabaseSystemEventNode
    
    Returns:
  - setPriorityEventsPerPoll
```
public void setPriorityEventsPerPoll(int priorityEventsPerPoll)
```
    Specified by:
    
    setPriorityEventsPerPoll in interface DatabaseSystemEventNode
  - getGlobalEventsPerPoll
```
public int getGlobalEventsPerPoll()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The number of EventScopeType.GLOBAL events to retrieve in each poll. This can be increased to process more events at any given time at the cost of prolonged CPU consumption. It is likely advantageous to throttle event consumption to avoid overly taxing the system and penalizing other operations. Also, smaller event processing groups allows the system to respond more quickly to events that utilize the priority feature (see SystemEvent.getPriority(). The default value is 5. This does not include events of type GLOBAL_DURABLE.
    See the discussion on DatabaseSystemEventNode.getPriorityEventsPerPoll() for similar configuration related to special priority events.
    
    Specified by:
    
    getGlobalEventsPerPoll in interface DatabaseSystemEventNode
    
    Returns:
  - setGlobalEventsPerPoll
```
public void setGlobalEventsPerPoll(int globalEventsPerPoll)
```
    Specified by:
    
    setGlobalEventsPerPoll in interface DatabaseSystemEventNode
  - getJobThreadPoolCount
```
public long getJobThreadPoolCount()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The number of threads actively polling for available EventScopeType.VM events. Defaults to 2. See jobThreadPoolCount for more info.
    
    Specified by:
    
    getJobThreadPoolCount in interface DatabaseSystemEventNode
    
    Returns:
  - setJobThreadPoolCount
```
public void setJobThreadPoolCount(long jobThreadPoolCount)
```
    Specified by:
    
    setJobThreadPoolCount in interface DatabaseSystemEventNode
  - getPriorityJobThreadPoolCount
```
public long getPriorityJobThreadPoolCount()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The number of threads actively polling for priority events (EventScopeType.VM or EventScopeType.GLOBAL). See priorityJobThreadPoolCount for more info. Default is 4.
    
    Specified by:
    
    getPriorityJobThreadPoolCount in interface DatabaseSystemEventNode
    
    Returns:
  - setPriorityJobThreadPoolCount
```
public void setPriorityJobThreadPoolCount(long priorityJobThreadPoolCount)
```
    Specified by:
    
    setPriorityJobThreadPoolCount in interface DatabaseSystemEventNode
  - getGlobalJobThreadPoolCount
```
public long getGlobalJobThreadPoolCount()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The number of threads actively polling for available EventScopeType.GLOBAL events. Defaults to 3. See globalJobThreadPoolCount for more info.
    
    Specified by:
    
    getGlobalJobThreadPoolCount in interface DatabaseSystemEventNode
    
    Returns:
  - setGlobalJobThreadPoolCount
```
public void setGlobalJobThreadPoolCount(long globalJobThreadPoolCount)
```
    Specified by:
    
    setGlobalJobThreadPoolCount in interface DatabaseSystemEventNode
  - getEventConsumers
```
public Map<String,List<SystemEventConsumer>> getEventConsumers()
```
    Description copied from interface: DatabaseSystemEventNode
    
    All the SystemEventConsumer instances registered in Spring.
    
    Specified by:
    
    getEventConsumers in interface DatabaseSystemEventNode
    
    Returns:
  - setEventConsumers
```
public void setEventConsumers(Map<String,List<SystemEventConsumer>> eventConsumers)
```
    Specified by:
    
    setEventConsumers in interface DatabaseSystemEventNode
  - getMissedDurableEventsPollingThresholdSeconds
```
public long getMissedDurableEventsPollingThresholdSeconds()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The maximum amount of time into the past that durable events should be retrieved. Durable events older than the threshold will be ignored. The default value is 604800 (7 days).
    
    Specified by:
    
    getMissedDurableEventsPollingThresholdSeconds in interface DatabaseSystemEventNode
    
    Returns:
  - getDurableEventsPerPoll
```
public int getDurableEventsPerPoll()
```
    Description copied from interface: DatabaseSystemEventNode
    
    The number of events of type DURABLE_GLOBAL to retrieve in each poll. The default value is 250. Durable events are always processed in order and do not take advantage of SystemEvent.getPriority().
    
    Specified by:
    
    getDurableEventsPerPoll in interface DatabaseSystemEventNode
    
    Returns:
  - setDurableEventsPerPoll
```
public void setDurableEventsPerPoll(int durableEventsPerPoll)
```
    Specified by:
    
    setDurableEventsPerPoll in interface DatabaseSystemEventNode
  - setMissedDurableEventsPollingThresholdSeconds
```
public void setMissedDurableEventsPollingThresholdSeconds(long missedDurableEventsPollingThresholdSeconds)
```
    Specified by:
    
    setMissedDurableEventsPollingThresholdSeconds in interface DatabaseSystemEventNode
  - isCreated
```
public boolean isCreated()
```
    Specified by:
    
    isCreated in interface DatabaseSystemEventNode
  - getNodeId
```
public String getNodeId()
```
    Specified by:
    
    getNodeId in interface DatabaseSystemEventNode
  - asyncExecuteEvent
```
protected void asyncExecuteEvent(boolean durable,
                                 QueueStatusThreadPoolTaskExecutor executor,
                                 Map<String,List<SystemEventConsumer>> consumers,
                                 SystemEvent event)
```
  - executeEvent
```
protected void executeEvent(SystemEventConsumer consumer,
                            SystemEvent lockedEvent)
```
  - removeUniversalDuplicates
```
protected void removeUniversalDuplicates(List<SystemEvent> events)
```
  - isLogEnabled
```
protected boolean isLogEnabled(int intervalCount)
```
  - clearLog
```
protected void clearLog()
```
  - incrementLog
```
protected void incrementLog()
```
  - getHostIpAddress
```
protected String getHostIpAddress()
```
    Retrieve the ip address for the current host. The default implementation is to use InetAddress.getLocalHost().getHostAddress(). Subclasses may override for different ip address determination.
    
    Returns:
  - isDebugEnabled
```
protected boolean isDebugEnabled()
```
  - isDebugEnabled
```
protected boolean isDebugEnabled(boolean checkInterval)
```
  - buildEventScheduler
```
protected void buildEventScheduler()
                            throws IOException,
                                   org.quartz.SchedulerException
```
    Throws:
    
    IOException
    
    org.quartz.SchedulerException

Class DatabaseSystemEventNodeImpl

Field Summary

Fields inherited from interface org.springframework.context.SmartLifecycle

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

pollingIntervalSeconds

eventsPerPoll

priorityPollingIntervalSeconds

priorityEventsPerPoll

globalPollingIntervalSeconds

globalEventsPerPoll

durableEventsPerPoll

missedDurableEventsPollingThresholdSeconds

eventConsumptionEnabled

eventNodeLogInterval

jobThreadPoolCount

priorityJobThreadPoolCount

globalJobThreadPoolCount

transUtil

systemEventDao

processStatusManager

systemEventCompressionHelper

processMonitorStatusManager

consumeWorker

priorityConsumeWorker

globalConsumeWorker

durableConsumeWorker

keepAliveWorker

systemEventSender

cacheInvalidationHelper

taskExecutor

eventLockUtil

threadInitializers

unsortedConsumers

eventConsumers

scheduler

priorityScheduler

globalScheduler

durableScheduler

keepAliveScheduler

pause

eventWorkerType

context

Constructor Detail

DatabaseSystemEventNodeImpl

Method Detail

isAutoStartup

stop

start

isRunning

getPhase

consumeLocalEvent

stop

setApplicationContext

determineHostWorkerType

executeEvents

getNodeRegistration

isPause

setPause

invalidateCacheElement

invalidateCacheElement

invalidateCacheRegion

getSystemEventDao

getPollingIntervalSeconds

setPollingIntervalSeconds

getPriorityPollingIntervalSeconds

setPriorityPollingIntervalSeconds

getGlobalPollingIntervalSeconds

setGlobalPollingIntervalSeconds

getEventsPerPoll

setEventsPerPoll

getPriorityEventsPerPoll

setPriorityEventsPerPoll

getGlobalEventsPerPoll

setGlobalEventsPerPoll

getJobThreadPoolCount

setJobThreadPoolCount

getPriorityJobThreadPoolCount