com.github.kagkarlsson.scheduler.boot.config.DbSchedulerProperties Maven / Gradle / Ivy
Show all versions of db-scheduler-spring-boot-starter Show documentation
/**
* Copyright (C) Gustav Karlsson
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.github.kagkarlsson.scheduler.boot.config;
import com.github.kagkarlsson.scheduler.jdbc.JdbcTaskRepository;
import com.github.kagkarlsson.scheduler.PollingStrategyConfig;
import com.github.kagkarlsson.scheduler.SchedulerBuilder;
import java.time.Duration;
import com.github.kagkarlsson.scheduler.logging.LogLevel;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.convert.DurationUnit;
import static java.time.temporal.ChronoUnit.*;
@ConfigurationProperties("db-scheduler")
public class DbSchedulerProperties {
/**
* Whether to enable auto configuration of the db-scheduler.
*/
private boolean enabled = true;
/***
* Number of threads.
*/
private int threads = 10;
/**
* How often to update the heartbeat timestamp for running executions.
*/
@DurationUnit(MINUTES)
private Duration heartbeatInterval = SchedulerBuilder.DEFAULT_HEARTBEAT_INTERVAL;
/**
*
Name of this scheduler-instance. The name is stored in the database when an execution is
* picked by a scheduler.
*
*
If the name is {@code null} or not configured, the hostname of the running machine will be
* used.
*/
private String schedulerName;
/**
*
Name of the table used to track task-executions. Must match the database. Change name in the
* table definitions accordingly when creating or modifying the table.
*/
private String tableName = JdbcTaskRepository.DEFAULT_TABLE_NAME;
/**
*
If this is enabled, the scheduler will attempt to directly execute tasks that are scheduled
* to {@code now()}, or a time in the past. For this to work, the call to {@code schedule(..)}
* must not occur from within a transaction, because the record will not yet be visible to the
* scheduler (if this is a requirement, see the method
* {@code scheduler.triggerCheckForDueExecutions())}
*/
private boolean immediateExecutionEnabled = false;
/**
*
How often the scheduler checks the database for due executions.
*/
@DurationUnit(SECONDS)
private Duration pollingInterval = SchedulerBuilder.DEFAULT_POLLING_INTERVAL;
/**
*
What polling-strategy to use. Valid values are: FETCH,LOCK_AND_FETCH
*/
private PollingStrategyConfig.Type pollingStrategy = SchedulerBuilder.DEFAULT_POLLING_STRATEGY.type;
/**
*
The limit at which more executions are fetched from the database after fetching a full batch.
*/
private double pollingStrategyLowerLimitFractionOfThreads = SchedulerBuilder.DEFAULT_POLLING_STRATEGY.lowerLimitFractionOfThreads;
/**
* For Type=FETCH, the number of due executions fetched from the database in each batch.
* For Type=LOCK_AND_FETCH, the maximum number of executions to pick and queue for execution.
*/
private double pollingStrategyUpperLimitFractionOfThreads = SchedulerBuilder.DEFAULT_POLLING_STRATEGY.upperLimitFractionOfThreads;
/**
* Whether to start the scheduler when the application context has been loaded or as soon as
* possible.
*/
private boolean delayStartupUntilContextReady = false;
/**
*
The time after which executions with unknown tasks are automatically deleted.
*/
@DurationUnit(HOURS)
private Duration deleteUnresolvedAfter = SchedulerBuilder.DEFAULT_DELETION_OF_UNRESOLVED_TASKS_DURATION;
/**
* How long the scheduler will wait before interrupting executor-service threads.
* If you find yourself using this, consider if it is possible to instead regularly check
* executionContext.getSchedulerState().isShuttingDown() in the ExecutionHandler and abort long-running task.
*/
@DurationUnit(SECONDS)
private Duration shutdownMaxWait = SchedulerBuilder.SHUTDOWN_MAX_WAIT;
/**
* Which log level to use when logging task failures. Defaults to {@link LogLevel#DEBUG}.
*/
private LogLevel failureLoggerLevel = SchedulerBuilder.DEFAULT_FAILURE_LOG_LEVEL;
/**
* Whether or not to log the {@link Throwable} that caused a task to fail.
*/
private boolean failureLoggerLogStackTrace = SchedulerBuilder.LOG_STACK_TRACE_ON_FAILURE;
public boolean isEnabled() {
return enabled;
}
public void setEnabled(final boolean enabled) {
this.enabled = enabled;
}
public int getThreads() {
return threads;
}
public void setThreads(final int threads) {
this.threads = threads;
}
public Duration getHeartbeatInterval() {
return heartbeatInterval;
}
public void setHeartbeatInterval(final Duration heartbeatInterval) {
this.heartbeatInterval = heartbeatInterval;
}
public String getSchedulerName() {
return schedulerName;
}
public void setSchedulerName(String schedulerName) {
this.schedulerName = schedulerName;
}
public String getTableName() {
return tableName;
}
public void setTableName(final String tableName) {
this.tableName = tableName;
}
public boolean isImmediateExecutionEnabled() {
return immediateExecutionEnabled;
}
public void setImmediateExecutionEnabled(boolean immediateExecutionEnabled) {
this.immediateExecutionEnabled = immediateExecutionEnabled;
}
public Duration getPollingInterval() {
return pollingInterval;
}
public void setPollingInterval(final Duration pollingInterval) {
this.pollingInterval = pollingInterval;
}
public boolean isDelayStartupUntilContextReady() {
return delayStartupUntilContextReady;
}
public void setDelayStartupUntilContextReady(final boolean delayStartupUntilContextReady) {
this.delayStartupUntilContextReady = delayStartupUntilContextReady;
}
public Duration getDeleteUnresolvedAfter() {
return deleteUnresolvedAfter;
}
public void setDeleteUnresolvedAfter(Duration deleteUnresolvedAfter) {
this.deleteUnresolvedAfter = deleteUnresolvedAfter;
}
public Duration getShutdownMaxWait() {
return shutdownMaxWait;
}
public void setShutdownMaxWait(Duration shutdownMaxWait) {
this.shutdownMaxWait = shutdownMaxWait;
}
public LogLevel getFailureLoggerLevel() {
return failureLoggerLevel;
}
public void setFailureLoggerLevel(LogLevel failureLoggerLevel) {
this.failureLoggerLevel = failureLoggerLevel;
}
public boolean isFailureLoggerLogStackTrace() {
return failureLoggerLogStackTrace;
}
public void setFailureLoggerLogStackTrace(boolean failureLoggerLogStackTrace) {
this.failureLoggerLogStackTrace = failureLoggerLogStackTrace;
}
public PollingStrategyConfig.Type getPollingStrategy() {
return pollingStrategy;
}
public void setPollingStrategy(PollingStrategyConfig.Type pollingStrategy) {
this.pollingStrategy = pollingStrategy;
}
public double getPollingStrategyLowerLimitFractionOfThreads() {
return pollingStrategyLowerLimitFractionOfThreads;
}
public void setPollingStrategyLowerLimitFractionOfThreads(double pollingStrategyLowerLimitFractionOfThreads) {
this.pollingStrategyLowerLimitFractionOfThreads = pollingStrategyLowerLimitFractionOfThreads;
}
public double getPollingStrategyUpperLimitFractionOfThreads() {
return pollingStrategyUpperLimitFractionOfThreads;
}
public void setPollingStrategyUpperLimitFractionOfThreads(double pollingStrategyUpperLimitFractionOfThreads) {
this.pollingStrategyUpperLimitFractionOfThreads = pollingStrategyUpperLimitFractionOfThreads;
}
}