package org.apereo.cas.configuration.model.support.redis;
import org.apereo.cas.configuration.model.core.util.CryptographyProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
/**
* Configuration properties for Redis.
*
* @author serv
* @since 5.1.0
*/
public class RedisTicketRegistryProperties {
/**
* Database index used by the connection factory.
*/
private int database;
/**
* Redis server host.
*/
private String host = "localhost";
/**
* Login password of the redis server.
*/
private String password;
/**
* Redis server port.
*/
private int port = 6379;
/**
* Connection timeout in milliseconds.
*/
private int timeout;
private Pool pool;
@NestedConfigurationProperty
private CryptographyProperties crypto = new CryptographyProperties();
public CryptographyProperties getCrypto() {
return crypto;
}
public void setCrypto(final CryptographyProperties crypto) {
this.crypto = crypto;
}
public int getDatabase() {
return this.database;
}
public void setDatabase(final int database) {
this.database = database;
}
public String getHost() {
return this.host;
}
public void setHost(final String host) {
this.host = host;
}
public String getPassword() {
return this.password;
}
public void setPassword(final String password) {
this.password = password;
}
public int getPort() {
return this.port;
}
public void setPort(final int port) {
this.port = port;
}
public void setTimeout(final int timeout) {
this.timeout = timeout;
}
public int getTimeout() {
return this.timeout;
}
public Pool getPool() {
return this.pool;
}
public void setPool(final Pool pool) {
this.pool = pool;
}
/**
* Pool properties.
*/
public static class Pool {
/**
* Max number of "idle" connections in the pool. Use a negative value to indicate
* an unlimited number of idle connections.
*/
private int maxIdle = 8;
/**
* Target for the minimum number of idle connections to maintain in the pool. This
* setting only has an effect if it is positive.
*/
private int minIdle;
/**
* Max number of connections that can be allocated by the pool at a given time.
* Use a negative value for no limit.
*/
private int maxActive = 8;
/**
* Maximum amount of time (in milliseconds) a connection allocation should block
* before throwing an exception when the pool is exhausted. Use a negative value
* to block indefinitely.
*/
private int maxWait = -1;
public int getMaxIdle() {
return this.maxIdle;
}
public void setMaxIdle(final int maxIdle) {
this.maxIdle = maxIdle;
}
public int getMinIdle() {
return this.minIdle;
}
public void setMinIdle(final int minIdle) {
this.minIdle = minIdle;
}
public int getMaxActive() {
return this.maxActive;
}
public void setMaxActive(final int maxActive) {
this.maxActive = maxActive;
}
public int getMaxWait() {
return this.maxWait;
}
public void setMaxWait(final int maxWait) {
this.maxWait = maxWait;
}
}
}