@Override
public ThreadPoolExecutor getThreadPool(
HystrixThreadPoolKey threadPoolKey,
HystrixProperty<Integer> corePoolSize,
HystrixProperty<Integer> maximumPoolSize,
HystrixProperty<Integer> keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
final String nameFormat =
Joiner.on('-').join(ImmutableList.of("hystrix"), threadPoolKey.name(), "%d");
final ThreadFactory threadFactory =
new ThreadFactoryBuilder().setNameFormat(nameFormat).build();
final String key = threadPoolKey.name();
final ThreadPoolExecutor existing =
executors.putIfAbsent(
key,
new ThreadPoolExecutor(
corePoolSize.get(),
maximumPoolSize.get(),
keepAliveTime.get(),
unit,
workQueue,
threadFactory));
final ThreadPoolExecutor threadPoolExecutor = executors.get(key);
if (existing == null) {
environment
.lifecycle()
.manage(new ExecutorServiceManager(threadPoolExecutor, Duration.seconds(5), nameFormat));
}
return threadPoolExecutor;
}
@Test
public void testFullConfiguration() throws Exception {
DataSourceFactory ds = getDataSourceFactory("yaml/full_db_pool.yml");
assertThat(ds.getDriverClass()).isEqualTo("org.postgresql.Driver");
assertThat(ds.getUser()).isEqualTo("pg-user");
assertThat(ds.getUrl()).isEqualTo("jdbc:postgresql://db.example.com/db-prod");
assertThat(ds.getPassword()).isEqualTo("iAMs00perSecrEET");
assertThat(ds.getProperties()).containsEntry("charSet", "UTF-8");
assertThat(ds.getMaxWaitForConnection()).isEqualTo(Duration.seconds(1));
assertThat(ds.getValidationQuery()).isEqualTo("/* MyService Health Check */ SELECT 1");
assertThat(ds.getMinSize()).isEqualTo(8);
assertThat(ds.getInitialSize()).isEqualTo(15);
assertThat(ds.getMaxSize()).isEqualTo(32);
assertThat(ds.getCheckConnectionWhileIdle()).isFalse();
assertThat(ds.getEvictionInterval()).isEqualTo(Duration.seconds(10));
assertThat(ds.getMinIdleTime()).isEqualTo(Duration.minutes(1));
assertThat(ds.getValidationInterval()).isEqualTo(Duration.minutes(1));
assertThat(ds.isAutoCommentsEnabled()).isFalse();
assertThat(ds.getReadOnlyByDefault()).isFalse();
assertThat(ds.isRemoveAbandoned()).isTrue();
assertThat(ds.getRemoveAbandonedTimeout()).isEqualTo(Duration.seconds(15L));
assertThat(ds.getAbandonWhenPercentageFull()).isEqualTo(75);
assertThat(ds.isAlternateUsernamesAllowed()).isTrue();
assertThat(ds.getCommitOnReturn()).isTrue();
assertThat(ds.getRollbackOnReturn()).isTrue();
assertThat(ds.getAutoCommitByDefault()).isFalse();
assertThat(ds.getDefaultCatalog()).isEqualTo("test_catalog");
assertThat(ds.getDefaultTransactionIsolation())
.isEqualTo(DataSourceFactory.TransactionIsolation.READ_COMMITTED);
assertThat(ds.getUseFairQueue()).isFalse();
assertThat(ds.getInitializationQuery())
.isEqualTo("insert into connections_log(ts) values (now())");
assertThat(ds.getLogAbandonedConnections()).isEqualTo(true);
assertThat(ds.getLogValidationErrors()).isEqualTo(true);
assertThat(ds.getMaxConnectionAge()).isEqualTo(Optional.of(Duration.hours(1)));
assertThat(ds.getCheckConnectionOnBorrow()).isEqualTo(true);
assertThat(ds.getCheckConnectionOnConnect()).isEqualTo(false);
assertThat(ds.getCheckConnectionOnReturn()).isEqualTo(true);
assertThat(ds.getValidationQueryTimeout()).isEqualTo(Optional.of(Duration.seconds(3)));
assertThat(ds.getValidatorClassName())
.isEqualTo(Optional.of("io.dropwizard.db.CustomConnectionValidator"));
}
@Test
public void testMinimalConfiguration() throws Exception {
DataSourceFactory ds = getDataSourceFactory("yaml/minimal_db_pool.yml");
assertThat(ds.getDriverClass()).isEqualTo("org.postgresql.Driver");
assertThat(ds.getUser()).isEqualTo("pg-user");
assertThat(ds.getUrl()).isEqualTo("jdbc:postgresql://db.example.com/db-prod");
assertThat(ds.getPassword()).isEqualTo("iAMs00perSecrEET");
assertThat(ds.getProperties()).isEmpty();
assertThat(ds.getMaxWaitForConnection()).isEqualTo(Duration.seconds(30));
assertThat(ds.getValidationQuery()).isEqualTo("/* Health Check */ SELECT 1");
assertThat(ds.getMinSize()).isEqualTo(10);
assertThat(ds.getInitialSize()).isEqualTo(10);
assertThat(ds.getMaxSize()).isEqualTo(100);
assertThat(ds.getCheckConnectionWhileIdle()).isTrue();
assertThat(ds.getEvictionInterval()).isEqualTo(Duration.seconds(5));
assertThat(ds.getMinIdleTime()).isEqualTo(Duration.minutes(1));
assertThat(ds.getValidationInterval()).isEqualTo(Duration.seconds(30));
assertThat(ds.isAutoCommentsEnabled()).isTrue();
assertThat(ds.getReadOnlyByDefault()).isNull();
assertThat(ds.isRemoveAbandoned()).isFalse();
assertThat(ds.getRemoveAbandonedTimeout()).isEqualTo(Duration.seconds(60L));
assertThat(ds.getAbandonWhenPercentageFull()).isEqualTo(0);
assertThat(ds.isAlternateUsernamesAllowed()).isFalse();
assertThat(ds.getCommitOnReturn()).isFalse();
assertThat(ds.getRollbackOnReturn()).isFalse();
assertThat(ds.getAutoCommitByDefault()).isNull();
assertThat(ds.getDefaultCatalog()).isNull();
assertThat(ds.getDefaultTransactionIsolation())
.isEqualTo(DataSourceFactory.TransactionIsolation.DEFAULT);
assertThat(ds.getUseFairQueue()).isTrue();
assertThat(ds.getInitializationQuery()).isNull();
assertThat(ds.getLogAbandonedConnections()).isEqualTo(false);
assertThat(ds.getLogValidationErrors()).isEqualTo(false);
assertThat(ds.getMaxConnectionAge()).isEqualTo(Optional.empty());
assertThat(ds.getCheckConnectionOnBorrow()).isEqualTo(false);
assertThat(ds.getCheckConnectionOnConnect()).isEqualTo(true);
assertThat(ds.getCheckConnectionOnReturn()).isEqualTo(false);
assertThat(ds.getValidationQueryTimeout()).isEqualTo(Optional.empty());
}
public class StreamCreateConfiguration {
private static final Logger LOG = LoggerFactory.getLogger(StreamCreateConfiguration.class);
@Min(1)
private int shardCount = 1;
@Valid @NotNull private Duration retryPeriod = Duration.seconds(5);
@Min(1)
private Integer maxAttempts;
@JsonProperty
public int getShardCount() {
return shardCount;
}
@JsonProperty
public void setShardCount(int shardCount) {
this.shardCount = shardCount;
}
@JsonIgnore
public StreamCreateConfiguration shardCount(int shardCount) {
this.setShardCount(shardCount);
return this;
}
@JsonProperty
public Duration getRetryPeriod() {
return retryPeriod;
}
@JsonProperty
public void setRetryPeriod(Duration retryPeriod) {
this.retryPeriod = retryPeriod;
}
@JsonProperty
public StreamCreateConfiguration retryPeriod(Duration retryPeriod) {
this.setRetryPeriod(retryPeriod);
return this;
}
@JsonProperty
public Integer getMaxAttempts() {
return maxAttempts;
}
@JsonProperty
public void setMaxAttempts(Integer maxAttempts) {
this.maxAttempts = maxAttempts;
}
@JsonIgnore
public StreamCreateConfiguration maxAttempts(Integer maxAttempts) {
this.setMaxAttempts(maxAttempts);
return this;
}
@JsonIgnore
public boolean setupStream(AmazonKinesis kinesis, String streamName) {
boolean setup = false;
Preconditions.checkState(!Strings.isNullOrEmpty(streamName), "streamName was not specified");
try {
DescribeStreamResult result;
if (getRetryPeriod() != null) {
Integer retryAttempts = getMaxAttempts();
while (retryAttempts == null || retryAttempts > 0) {
try {
result = kinesis.describeStream(streamName);
if ("active".equalsIgnoreCase(result.getStreamDescription().getStreamStatus())) {
LOG.info("stream {} is active", streamName);
setup = true;
break;
}
} catch (NullPointerException | ResourceNotFoundException e) {
createStream(kinesis, streamName);
}
Thread.sleep(retryPeriod.toMilliseconds());
if (retryAttempts != null) {
retryAttempts--;
}
}
}
} catch (InterruptedException e) {
LOG.error(
"Needed to create stream {} but was interrupted, nothing is guaranteed now", streamName);
}
return setup;
}
private void createStream(AmazonKinesis kinesis, String streamName) {
LOG.info(
String.format(
"stream %s was not found, creating with %d shards", streamName, getShardCount()));
try {
final CreateStreamResult stream = kinesis.createStream(streamName, getShardCount());
} catch (ResourceInUseException ue) {
LOG.info(String.format("failed to create stream %s because it already existed", streamName));
} catch (Exception e) {
LOG.error(String.format("failed to create stream %s", e), e);
}
}
}
/** Jackson friendly object for holding configuration information about a ZooKeeper ensemble. */
public class ZooKeeperConfiguration {
private static final String DEFAULT_CONNECT_STRING = "localhost:2181";
private static final RetryPolicy DEFAULT_RETRY_POLICY =
new BoundedExponentialBackoffRetry(100, 1000, 5);
@NotNull
@JsonProperty("connectString")
@UnwrapValidatedValue(false)
private Optional<String> _connectString = Optional.absent();
@JsonProperty("namespace")
private Optional<String> _namespace = Optional.absent();
@JsonProperty("retryPolicy")
private RetryPolicy _configRetryPolicy = null;
@JsonProperty("sessionTimeout")
private Duration _sessionTimeout = Duration.seconds(60);
@JsonProperty("connectionTimeout")
private Duration _connectionTimeout = Duration.seconds(15);
/**
* Used to hold a retry policy provided by a setter. This needs to be separate from {@code
* _retryPolicy} because we want callers to be able to specify any Curator {@link
* org.apache.curator.RetryPolicy} implementation instead of the inner {@link RetryPolicy} and its
* subclasses that are used entirely to hold Jackson annotations.
*/
private Optional<org.apache.curator.RetryPolicy> _setterRetryPolicy = Optional.absent();
/**
* Return a new Curator connection to the ensemble. It is the caller's responsibility to start and
* close the connection.
*/
public CuratorFramework newCurator() {
// Make all of the curator threads daemon threads so they don't block the JVM from terminating.
// Also label them
// with the ensemble they're connecting to, in case someone is trying to sort through a thread
// dump.
ThreadFactory threadFactory =
new ThreadFactoryBuilder()
.setNameFormat("CuratorFramework[" + _connectString.or(DEFAULT_CONNECT_STRING) + "]-%d")
.setDaemon(true)
.build();
org.apache.curator.RetryPolicy retry =
_setterRetryPolicy.or(
(_configRetryPolicy != null) ? _configRetryPolicy : DEFAULT_RETRY_POLICY);
return CuratorFrameworkFactory.builder()
.ensembleProvider(new ResolvingEnsembleProvider(_connectString.or(DEFAULT_CONNECT_STRING)))
.retryPolicy(retry)
.sessionTimeoutMs(Ints.checkedCast(_sessionTimeout.toMilliseconds()))
.connectionTimeoutMs(Ints.checkedCast(_connectionTimeout.toMilliseconds()))
.namespace(_namespace.orNull())
.threadFactory(threadFactory)
.build();
}
/**
* Return a managed Curator connection. This created connection will be wrapped in a {@link
* ManagedCuratorFramework} and offered to the provided {@link Environment} parameter.
*
* @deprecated Use {@link #newManagedCurator(LifecycleEnvironment)} instead.
*/
@Deprecated
public CuratorFramework newManagedCurator(Environment env) {
return newManagedCurator(env.lifecycle());
}
/**
* Return a managed Curator connection. This created connection will be wrapped in a {@link
* ManagedCuratorFramework} and offered to the provided {@link LifecycleEnvironment} parameter.
*/
public CuratorFramework newManagedCurator(LifecycleEnvironment env) {
CuratorFramework curator = newCurator();
env.manage(new ManagedCuratorFramework(curator));
return curator;
}
@JsonIgnore
public Optional<String> getConnectString() {
return _connectString;
}
@JsonIgnore
public Optional<String> getNamespace() {
return _namespace;
}
@JsonIgnore
public Optional<org.apache.curator.RetryPolicy> getRetryPolicy() {
if (_setterRetryPolicy.isPresent()) {
return _setterRetryPolicy;
}
return Optional.<org.apache.curator.RetryPolicy>fromNullable(_configRetryPolicy);
}
@JsonIgnore
public void setConnectString(String connectString) {
_connectString = Optional.of(connectString);
}
@JsonIgnore
public void setNamespace(String namespace) {
_namespace = Optional.of(namespace);
}
@JsonIgnore
public void setRetryPolicy(org.apache.curator.RetryPolicy retryPolicy) {
_setterRetryPolicy = Optional.of(retryPolicy);
}
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
@JsonSubTypes({
@JsonSubTypes.Type(
value = BoundedExponentialBackoffRetry.class,
name = "boundedExponentialBackoff"),
@JsonSubTypes.Type(value = ExponentialBackoffRetry.class, name = "exponentialBackoff"),
@JsonSubTypes.Type(value = RetryNTimes.class, name = "nTimes"),
@JsonSubTypes.Type(value = RetryUntilElapsed.class, name = "untilElapsed")
})
static interface RetryPolicy extends org.apache.curator.RetryPolicy {}
private static final class BoundedExponentialBackoffRetry
extends org.apache.curator.retry.BoundedExponentialBackoffRetry implements RetryPolicy {
@JsonCreator
public BoundedExponentialBackoffRetry(
@JsonProperty("baseSleepTimeMs") int baseSleepTimeMs,
@JsonProperty("maxSleepTimeMs") int maxSleepTimeMs,
@JsonProperty("maxRetries") int maxRetries) {
super(baseSleepTimeMs, maxSleepTimeMs, maxRetries);
}
}
private static final class ExponentialBackoffRetry
extends org.apache.curator.retry.ExponentialBackoffRetry implements RetryPolicy {
@JsonCreator
public ExponentialBackoffRetry(
@JsonProperty("baseSleepTimeMs") int baseSleepTimeMs,
@JsonProperty("maxRetries") int maxRetries) {
super(baseSleepTimeMs, maxRetries);
}
}
private static final class RetryNTimes extends org.apache.curator.retry.RetryNTimes
implements RetryPolicy {
@JsonCreator
public RetryNTimes(
@JsonProperty("n") int n,
@JsonProperty("sleepMsBetweenRetries") int sleepMsBetweenRetries) {
super(n, sleepMsBetweenRetries);
}
}
private static final class RetryUntilElapsed extends org.apache.curator.retry.RetryUntilElapsed
implements RetryPolicy {
public RetryUntilElapsed(
@JsonProperty("maxElapsedTimeMs") int maxElapsedTimeMs,
@JsonProperty("sleepMsBetweenRetries") int sleepMsBetweenRetries) {
super(maxElapsedTimeMs, sleepMsBetweenRetries);
}
}
}
/**
* A base class for {@link ServerFactory} implementations.
*
* <p><b>Configuration Parameters:</b>
*
* <table>
* <tr>
* <td>Name</td>
* <td>Default</td>
* <td>Description</td>
* </tr>
* <tr>
* <td>{@code requestLog}</td>
* <td></td>
* <td>The {@link RequestLogFactory request log} configuration.</td>
* </tr>
* <tr>
* <td>{@code gzip}</td>
* <td></td>
* <td>The {@link GzipHandlerFactory GZIP} configuration.</td>
* </tr>
* <tr>
* <td>{@code serverPush}</td>
* <td></td>
* <td>The {@link ServerPushFilterFactory} configuration.</td>
* </tr>
* <tr>
* <td>{@code maxThreads}</td>
* <td>1024</td>
* <td>The maximum number of threads to use for requests.</td>
* </tr>
* <tr>
* <td>{@code minThreads}</td>
* <td>8</td>
* <td>The minimum number of threads to use for requests.</td>
* </tr>
* <tr>
* <td>{@code maxQueuedRequests}</td>
* <td>1024</td>
* <td>The maximum number of requests to queue before blocking the acceptors.</td>
* </tr>
* <tr>
* <td>{@code idleThreadTimeout}</td>
* <td>1 minute</td>
* <td>The amount of time a worker thread can be idle before being stopped.</td>
* </tr>
* <tr>
* <td>{@code nofileSoftLimit}</td>
* <td>(none)</td>
* <td>
* The number of open file descriptors before a soft error is issued. <b>Requires Jetty's
* {@code libsetuid.so} on {@code java.library.path}.</b>
* </td>
* </tr>
* <tr>
* <td>{@code nofileHardLimit}</td>
* <td>(none)</td>
* <td>
* The number of open file descriptors before a hard error is issued. <b>Requires Jetty's
* {@code libsetuid.so} on {@code java.library.path}.</b>
* </td>
* </tr>
* <tr>
* <td>{@code gid}</td>
* <td>(none)</td>
* <td>
* The group ID to switch to once the connectors have started. <b>Requires Jetty's
* {@code libsetuid.so} on {@code java.library.path}.</b>
* </td>
* </tr>
* <tr>
* <td>{@code uid}</td>
* <td>(none)</td>
* <td>
* The user ID to switch to once the connectors have started. <b>Requires Jetty's
* {@code libsetuid.so} on {@code java.library.path}.</b>
* </td>
* </tr>
* <tr>
* <td>{@code user}</td>
* <td>(none)</td>
* <td>
* The username to switch to once the connectors have started. <b>Requires Jetty's
* {@code libsetuid.so} on {@code java.library.path}.</b>
* </td>
* </tr>
* <tr>
* <td>{@code group}</td>
* <td>(none)</td>
* <td>
* The group to switch to once the connectors have started. <b>Requires Jetty's
* {@code libsetuid.so} on {@code java.library.path}.</b>
* </td>
* </tr>
* <tr>
* <td>{@code umask}</td>
* <td>(none)</td>
* <td>
* The umask to switch to once the connectors have started. <b>Requires Jetty's
* {@code libsetuid.so} on {@code java.library.path}.</b>
* </td>
* </tr>
* <tr>
* <td>{@code startsAsRoot}</td>
* <td>(none)</td>
* <td>
* Whether or not the Dropwizard application is started as a root user. <b>Requires
* Jetty's {@code libsetuid.so} on {@code java.library.path}.</b>
* </td>
* </tr>
* <tr>
* <td>{@code registerDefaultExceptionMappers}</td>
* <td>true</td>
* <td>
* Whether or not the default Jersey ExceptionMappers should be registered.
* Set this to false if you want to register your own.
* </td>
* </tr>
* <tr>
* <td>{@code shutdownGracePeriod}</td>
* <td>30 seconds</td>
* <td>
* The maximum time to wait for Jetty, and all Managed instances, to cleanly shutdown
* before forcibly terminating them.
* </td>
* </tr>
* <tr>
* <td>{@code allowedMethods}</td>
* <td>GET, POST, PUT, DELETE, HEAD, OPTIONS, PATCH</td>
* <td>
* The set of allowed HTTP methods. Others will be rejected with a
* 405 Method Not Allowed response.
* </td>
* </tr>
* <tr>
* <td>{@code rootPath}</td>
* <td>/*</td>
* <td>
* The URL pattern relative to {@code applicationContextPath} from which the JAX-RS resources will be served.
* </td>
* </tr>
* </table>
*
* @see DefaultServerFactory
* @see SimpleServerFactory
*/
public abstract class AbstractServerFactory implements ServerFactory {
private static final Logger LOGGER = LoggerFactory.getLogger(ServerFactory.class);
private static final Pattern WINDOWS_NEWLINE = Pattern.compile("\\r\\n?");
@Valid @NotNull private RequestLogFactory requestLog = new LogbackAccessRequestLogFactory();
@Valid @NotNull private GzipHandlerFactory gzip = new GzipHandlerFactory();
@Valid @NotNull private ServerPushFilterFactory serverPush = new ServerPushFilterFactory();
@Min(2)
private int maxThreads = 1024;
@Min(1)
private int minThreads = 8;
private int maxQueuedRequests = 1024;
@MinDuration(1)
private Duration idleThreadTimeout = Duration.minutes(1);
@Min(1)
private Integer nofileSoftLimit;
@Min(1)
private Integer nofileHardLimit;
private Integer gid;
private Integer uid;
private String user;
private String group;
private String umask;
private Boolean startsAsRoot;
private Boolean registerDefaultExceptionMappers = Boolean.TRUE;
private Duration shutdownGracePeriod = Duration.seconds(30);
@NotNull private Set<String> allowedMethods = AllowedMethodsFilter.DEFAULT_ALLOWED_METHODS;
private Optional<String> jerseyRootPath = Optional.absent();
@JsonIgnore
@ValidationMethod(message = "must have a smaller minThreads than maxThreads")
public boolean isThreadPoolSizedCorrectly() {
return minThreads <= maxThreads;
}
@JsonProperty("requestLog")
public RequestLogFactory getRequestLogFactory() {
return requestLog;
}
@JsonProperty("requestLog")
public void setRequestLogFactory(RequestLogFactory requestLog) {
this.requestLog = requestLog;
}
@JsonProperty("gzip")
public GzipHandlerFactory getGzipFilterFactory() {
return gzip;
}
@JsonProperty("gzip")
public void setGzipFilterFactory(GzipHandlerFactory gzip) {
this.gzip = gzip;
}
@JsonProperty("serverPush")
public ServerPushFilterFactory getServerPush() {
return serverPush;
}
@JsonProperty("serverPush")
public void setServerPush(ServerPushFilterFactory serverPush) {
this.serverPush = serverPush;
}
@JsonProperty
public int getMaxThreads() {
return maxThreads;
}
@JsonProperty
public void setMaxThreads(int count) {
this.maxThreads = count;
}
@JsonProperty
public int getMinThreads() {
return minThreads;
}
@JsonProperty
public void setMinThreads(int count) {
this.minThreads = count;
}
@JsonProperty
public int getMaxQueuedRequests() {
return maxQueuedRequests;
}
@JsonProperty
public void setMaxQueuedRequests(int maxQueuedRequests) {
this.maxQueuedRequests = maxQueuedRequests;
}
@JsonProperty
public Duration getIdleThreadTimeout() {
return idleThreadTimeout;
}
@JsonProperty
public void setIdleThreadTimeout(Duration idleThreadTimeout) {
this.idleThreadTimeout = idleThreadTimeout;
}
@JsonProperty
public Integer getNofileSoftLimit() {
return nofileSoftLimit;
}
@JsonProperty
public void setNofileSoftLimit(Integer nofileSoftLimit) {
this.nofileSoftLimit = nofileSoftLimit;
}
@JsonProperty
public Integer getNofileHardLimit() {
return nofileHardLimit;
}
@JsonProperty
public void setNofileHardLimit(Integer nofileHardLimit) {
this.nofileHardLimit = nofileHardLimit;
}
@JsonProperty
public Integer getGid() {
return gid;
}
@JsonProperty
public void setGid(Integer gid) {
this.gid = gid;
}
@JsonProperty
public Integer getUid() {
return uid;
}
@JsonProperty
public void setUid(Integer uid) {
this.uid = uid;
}
@JsonProperty
public String getUser() {
return user;
}
@JsonProperty
public void setUser(String user) {
this.user = user;
}
@JsonProperty
public String getGroup() {
return group;
}
@JsonProperty
public void setGroup(String group) {
this.group = group;
}
@JsonProperty
public String getUmask() {
return umask;
}
@JsonProperty
public void setUmask(String umask) {
this.umask = umask;
}
@JsonProperty
public Boolean getStartsAsRoot() {
return startsAsRoot;
}
@JsonProperty
public void setStartsAsRoot(Boolean startsAsRoot) {
this.startsAsRoot = startsAsRoot;
}
public Boolean getRegisterDefaultExceptionMappers() {
return registerDefaultExceptionMappers;
}
public void setRegisterDefaultExceptionMappers(Boolean registerDefaultExceptionMappers) {
this.registerDefaultExceptionMappers = registerDefaultExceptionMappers;
}
@JsonProperty
public Duration getShutdownGracePeriod() {
return shutdownGracePeriod;
}
@JsonProperty
public void setShutdownGracePeriod(Duration shutdownGracePeriod) {
this.shutdownGracePeriod = shutdownGracePeriod;
}
@JsonProperty
public Set<String> getAllowedMethods() {
return allowedMethods;
}
@JsonProperty
public void setAllowedMethods(Set<String> allowedMethods) {
this.allowedMethods = allowedMethods;
}
@JsonProperty("rootPath")
public Optional<String> getJerseyRootPath() {
return jerseyRootPath;
}
@JsonProperty("rootPath")
public void setJerseyRootPath(String jerseyRootPath) {
this.jerseyRootPath = Optional.fromNullable(jerseyRootPath);
}
protected Handler createAdminServlet(
Server server,
MutableServletContextHandler handler,
MetricRegistry metrics,
HealthCheckRegistry healthChecks) {
configureSessionsAndSecurity(handler, server);
handler.setServer(server);
handler.getServletContext().setAttribute(MetricsServlet.METRICS_REGISTRY, metrics);
handler
.getServletContext()
.setAttribute(HealthCheckServlet.HEALTH_CHECK_REGISTRY, healthChecks);
handler.addServlet(new NonblockingServletHolder(new AdminServlet()), "/*");
handler
.addFilter(AllowedMethodsFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST))
.setInitParameter(
AllowedMethodsFilter.ALLOWED_METHODS_PARAM, Joiner.on(',').join(allowedMethods));
return handler;
}
private void configureSessionsAndSecurity(MutableServletContextHandler handler, Server server) {
handler.setServer(server);
if (handler.isSecurityEnabled()) {
handler.getSecurityHandler().setServer(server);
}
if (handler.isSessionsEnabled()) {
handler.getSessionHandler().setServer(server);
}
}
protected Handler createAppServlet(
Server server,
JerseyEnvironment jersey,
ObjectMapper objectMapper,
Validator validator,
MutableServletContextHandler handler,
@Nullable Servlet jerseyContainer,
MetricRegistry metricRegistry) {
configureSessionsAndSecurity(handler, server);
handler
.addFilter(AllowedMethodsFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST))
.setInitParameter(
AllowedMethodsFilter.ALLOWED_METHODS_PARAM, Joiner.on(',').join(allowedMethods));
handler.addFilter(ThreadNameFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST));
serverPush.addFilter(handler);
if (jerseyContainer != null) {
if (jerseyRootPath.isPresent()) {
jersey.setUrlPattern(jerseyRootPath.get());
}
jersey.register(new JacksonMessageBodyProvider(objectMapper));
jersey.register(new HibernateValidationFeature(validator));
if (registerDefaultExceptionMappers == null || registerDefaultExceptionMappers) {
jersey.register(new LoggingExceptionMapper<Throwable>() {});
jersey.register(new JerseyViolationExceptionMapper());
jersey.register(new JsonProcessingExceptionMapper());
jersey.register(new EarlyEofExceptionMapper());
}
handler.addServlet(new NonblockingServletHolder(jerseyContainer), jersey.getUrlPattern());
}
final InstrumentedHandler instrumented = new InstrumentedHandler(metricRegistry);
instrumented.setServer(server);
instrumented.setHandler(handler);
return instrumented;
}
protected ThreadPool createThreadPool(MetricRegistry metricRegistry) {
final BlockingQueue<Runnable> queue =
new BlockingArrayQueue<>(minThreads, maxThreads, maxQueuedRequests);
final InstrumentedQueuedThreadPool threadPool =
new InstrumentedQueuedThreadPool(
metricRegistry,
maxThreads,
minThreads,
(int) idleThreadTimeout.toMilliseconds(),
queue);
threadPool.setName("dw");
return threadPool;
}
protected Server buildServer(LifecycleEnvironment lifecycle, ThreadPool threadPool) {
final Server server = new Server(threadPool);
server.addLifeCycleListener(buildSetUIDListener());
lifecycle.attach(server);
final ErrorHandler errorHandler = new ErrorHandler();
errorHandler.setServer(server);
errorHandler.setShowStacks(false);
server.addBean(errorHandler);
server.setStopAtShutdown(true);
server.setStopTimeout(shutdownGracePeriod.toMilliseconds());
return server;
}
protected SetUIDListener buildSetUIDListener() {
final SetUIDListener listener = new SetUIDListener();
if (startsAsRoot != null) {
listener.setStartServerAsPrivileged(startsAsRoot);
}
if (gid != null) {
listener.setGid(gid);
}
if (uid != null) {
listener.setUid(uid);
}
if (user != null) {
listener.setUsername(user);
}
if (group != null) {
listener.setGroupname(group);
}
if (nofileHardLimit != null || nofileSoftLimit != null) {
final RLimit rlimit = new RLimit();
if (nofileHardLimit != null) {
rlimit.setHard(nofileHardLimit);
}
if (nofileSoftLimit != null) {
rlimit.setSoft(nofileSoftLimit);
}
listener.setRLimitNoFiles(rlimit);
}
if (umask != null) {
listener.setUmaskOctal(umask);
}
return listener;
}
protected Handler addRequestLog(Server server, Handler handler, String name) {
if (requestLog.isEnabled()) {
final RequestLogHandler requestLogHandler = new RequestLogHandler();
requestLogHandler.setRequestLog(requestLog.build(name));
// server should own the request log's lifecycle since it's already started,
// the handler might not become managed in case of an error which would leave
// the request log stranded
server.addBean(requestLogHandler.getRequestLog(), true);
requestLogHandler.setHandler(handler);
return requestLogHandler;
}
return handler;
}
protected Handler addStatsHandler(Handler handler) {
// Graceful shutdown is implemented via the statistics handler,
// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=420142
final StatisticsHandler statisticsHandler = new StatisticsHandler();
statisticsHandler.setHandler(handler);
return statisticsHandler;
}
protected Handler buildGzipHandler(Handler handler) {
return gzip.isEnabled() ? gzip.build(handler) : handler;
}
protected void printBanner(String name) {
try {
final String banner =
WINDOWS_NEWLINE
.matcher(
Resources.toString(Resources.getResource("banner.txt"), StandardCharsets.UTF_8))
.replaceAll("\n")
.replace("\n", String.format("%n"));
LOGGER.info(String.format("Starting {}%n{}"), name, banner);
} catch (IllegalArgumentException | IOException ignored) {
// don't display the banner if there isn't one
LOGGER.info("Starting {}", name);
}
}
}