[
https://issues.apache.org/jira/browse/CAMEL-12011?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16256715#comment-16256715
]
ASF GitHub Bot commented on CAMEL-12011:
----------------------------------------
oscerd closed pull request #2095: CAMEL-12011: Add RestletHost abstraction for
creation of Restlet server
URL: https://github.com/apache/camel/pull/2095
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git
a/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/DefaultRestletHost.java
b/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/DefaultRestletHost.java
new file mode 100644
index 00000000000..af45ab4ef2e
--- /dev/null
+++
b/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/DefaultRestletHost.java
@@ -0,0 +1,186 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.restlet;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.InvalidParameterException;
+import java.util.Arrays;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+
+import org.apache.camel.util.jsse.SSLContextParameters;
+import org.restlet.Component;
+import org.restlet.Server;
+import org.restlet.data.Parameter;
+import org.restlet.data.Protocol;
+import org.restlet.util.Series;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class DefaultRestletHost implements RestletHost {
+
+ private static final Logger LOG =
LoggerFactory.getLogger(DefaultRestletHost.class);
+ private final RestletHostOptions resletHostOptions;
+ private Server server;
+
+ public DefaultRestletHost(RestletHostOptions restletHostOptions) {
+ this.resletHostOptions = restletHostOptions;
+ }
+
+ @Override
+ public void configure(RestletEndpoint endpoint, Component component) {
+ server = createServer(endpoint, component);
+ component.getServers().add(server);
+
+ // Add any Restlet server parameters that were included
+ Series<Parameter> params = server.getContext().getParameters();
+
+ if ("https".equals(endpoint.getProtocol())) {
+ SSLContextParameters scp = endpoint.getSslContextParameters();
+ if (endpoint.getSslContextParameters() == null) {
+ throw new InvalidParameterException("Need to specify the
SSLContextParameters option here!");
+ }
+ try {
+ setupServerWithSSLContext(endpoint, params, scp);
+ } catch (Exception e) {
+ throw new IllegalStateException("Error configuring Restlet
server SSL context", e);
+ }
+ }
+
+ if (resletHostOptions.getControllerDaemon() != null) {
+ params.add("controllerDaemon",
resletHostOptions.getControllerDaemon().toString());
+ }
+ if (resletHostOptions.getControllerSleepTimeMs() != null) {
+ params.add("controllerSleepTimeMs",
resletHostOptions.getControllerSleepTimeMs().toString());
+ }
+ if (resletHostOptions.getInboundBufferSize() != null) {
+ params.add("inboundBufferSize",
resletHostOptions.getInboundBufferSize().toString());
+ }
+ if (resletHostOptions.getMaxConnectionsPerHost() != null) {
+ params.add("maxConnectionsPerHost",
resletHostOptions.getMaxConnectionsPerHost().toString());
+ }
+ if (resletHostOptions.getMaxQueued() != null) {
+ params.add("maxQueued",
resletHostOptions.getMaxQueued().toString());
+ }
+ if (resletHostOptions.getMaxThreads() != null) {
+ params.add("maxThreads",
resletHostOptions.getMaxThreads().toString());
+ }
+ if (resletHostOptions.getMaxTotalConnections() != null) {
+ params.add("maxTotalConnections",
resletHostOptions.getMaxTotalConnections().toString());
+ }
+ if (resletHostOptions.getMinThreads() != null) {
+ params.add("minThreads",
resletHostOptions.getMinThreads().toString());
+ }
+ if (resletHostOptions.getLowThreads() != null) {
+ params.add("lowThreads",
resletHostOptions.getLowThreads().toString());
+ }
+ if (resletHostOptions.getOutboundBufferSize() != null) {
+ params.add("outboundBufferSize",
resletHostOptions.getOutboundBufferSize().toString());
+ }
+ if (resletHostOptions.getPersistingConnections() != null) {
+ params.add("persistingConnections",
resletHostOptions.getPersistingConnections().toString());
+ }
+ if (resletHostOptions.getPipeliningConnections() != null) {
+ params.add("pipeliningConnections",
resletHostOptions.getPipeliningConnections().toString());
+ }
+ if (resletHostOptions.getThreadMaxIdleTimeMs() != null) {
+ params.add("threadMaxIdleTimeMs",
resletHostOptions.getThreadMaxIdleTimeMs().toString());
+ }
+ if (resletHostOptions.getUseForwardedForHeader() != null) {
+ params.add("useForwardedForHeader",
resletHostOptions.getUseForwardedForHeader().toString());
+ }
+ if (resletHostOptions.getReuseAddress() != null) {
+ params.add("reuseAddress",
resletHostOptions.getReuseAddress().toString());
+ }
+
+ LOG.debug("Setting parameters: {} to server: {}", params, server);
+ server.getContext().setParameters(params);
+ }
+
+ @Override
+ public void start() throws Exception {
+ server.start();
+ }
+
+ @Override
+ public void stop() throws Exception {
+ server.stop();
+ }
+
+ private Server createServer(RestletEndpoint endpoint, Component component)
{
+ // Consider hostname if provided. This is useful when loopback
interface is required for security reasons.
+ if (endpoint.getHost() != null) {
+ return new Server(component.getContext().createChildContext(),
Protocol.valueOf(endpoint.getProtocol()), endpoint.getHost(),
endpoint.getPort(), null);
+ } else {
+ return new Server(component.getContext().createChildContext(),
Protocol.valueOf(endpoint.getProtocol()), endpoint.getPort());
+ }
+ }
+
+ private void setupServerWithSSLContext(RestletEndpoint endpoint,
Series<Parameter> params, SSLContextParameters scp) throws
GeneralSecurityException, IOException {
+ // set the SSLContext parameters
+ params.add("sslContextFactory",
+ "org.restlet.engine.ssl.DefaultSslContextFactory");
+
+ SSLContext context = scp.createSSLContext(endpoint.getCamelContext());
+ SSLEngine engine = context.createSSLEngine();
+
+ params.add("enabledProtocols", String.join(" ",
Arrays.asList(engine.getEnabledProtocols())));
+ params.add("enabledCipherSuites", String.join(" ",
Arrays.asList(engine.getEnabledCipherSuites())));
+
+ if (scp.getSecureSocketProtocol() != null) {
+ params.add("protocol", scp.getSecureSocketProtocol());
+ }
+ if (scp.getServerParameters() != null &&
scp.getServerParameters().getClientAuthentication() != null) {
+ boolean b =
!scp.getServerParameters().getClientAuthentication().equals("NONE");
+ params.add("needClientAuthentication", String.valueOf(b));
+ }
+ if (scp.getKeyManagers() != null) {
+ if (scp.getKeyManagers().getAlgorithm() != null) {
+ params.add("keyManagerAlgorithm",
scp.getKeyManagers().getAlgorithm());
+ }
+ if (scp.getKeyManagers().getKeyPassword() != null) {
+ params.add("keyPassword",
scp.getKeyManagers().getKeyPassword());
+ }
+ if (scp.getKeyManagers().getKeyStore().getResource() != null) {
+ params.add("keyStorePath",
scp.getKeyManagers().getKeyStore().getResource());
+ }
+ if (scp.getKeyManagers().getKeyStore().getPassword() != null) {
+ params.add("keyStorePassword",
scp.getKeyManagers().getKeyStore().getPassword());
+ }
+ if (scp.getKeyManagers().getKeyStore().getType() != null) {
+ params.add("keyStoreType",
scp.getKeyManagers().getKeyStore().getType());
+ }
+ }
+
+ if (scp.getTrustManagers() != null) {
+ if (scp.getTrustManagers().getAlgorithm() != null) {
+ params.add("trustManagerAlgorithm",
scp.getKeyManagers().getAlgorithm());
+ }
+ if (scp.getTrustManagers().getKeyStore().getResource() != null) {
+ params.add("trustStorePath",
scp.getTrustManagers().getKeyStore().getResource());
+ }
+ if (scp.getTrustManagers().getKeyStore().getPassword() != null) {
+ params.add("trustStorePassword",
scp.getTrustManagers().getKeyStore().getPassword());
+ }
+ if (scp.getTrustManagers().getKeyStore().getType() != null) {
+ params.add("trustStoreType",
scp.getTrustManagers().getKeyStore().getType());
+ }
+ }
+ }
+}
diff --git
a/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletComponent.java
b/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletComponent.java
index b308df2f1bd..507c899462a 100644
---
a/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletComponent.java
+++
b/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletComponent.java
@@ -16,10 +16,7 @@
*/
package org.apache.camel.component.restlet;
-import java.io.IOException;
import java.net.URI;
-import java.security.GeneralSecurityException;
-import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@@ -27,8 +24,6 @@
import java.util.List;
import java.util.Locale;
import java.util.Map;
-import javax.net.ssl.SSLContext;
-import javax.net.ssl.SSLEngine;
import org.apache.camel.CamelContext;
import org.apache.camel.Consumer;
@@ -50,18 +45,13 @@
import org.apache.camel.util.ObjectHelper;
import org.apache.camel.util.ServiceHelper;
import org.apache.camel.util.URISupport;
-import org.apache.camel.util.jsse.SSLContextParameters;
import org.restlet.Component;
import org.restlet.Restlet;
-import org.restlet.Server;
import org.restlet.data.ChallengeScheme;
import org.restlet.data.Method;
-import org.restlet.data.Parameter;
-import org.restlet.data.Protocol;
import org.restlet.engine.Engine;
import org.restlet.security.ChallengeAuthenticator;
import org.restlet.security.MapVerifier;
-import org.restlet.util.Series;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -74,8 +64,8 @@
private static final Logger LOG =
LoggerFactory.getLogger(RestletComponent.class);
private static final Object LOCK = new Object();
- private final Map<String, Server> servers = new HashMap<String, Server>();
- private final Map<String, MethodBasedRouter> routers = new HashMap<String,
MethodBasedRouter>();
+ private final Map<String, RestletHost> restletHostRegistry = new
HashMap<>();
+ private final Map<String, MethodBasedRouter> routers = new HashMap<>();
private final Component component;
// options that can be set on the restlet server
@@ -233,7 +223,7 @@ protected void doStart() throws Exception {
protected void doStop() throws Exception {
component.stop();
// component stop will stop servers so we should clear our list as well
- servers.clear();
+ restletHostRegistry.clear();
// routers map entries are removed as consumer stops and servers map
// is not touch so to keep in sync with component's servers
super.doStop();
@@ -329,150 +319,72 @@ private MethodBasedRouter getMethodRouter(String
uriPattern, boolean addIfEmpty)
}
}
- protected Server createServer(RestletEndpoint endpoint) {
- // Consider hostname if provided. This is useful when loopback
interface is required for security reasons.
- if (endpoint.getHost() != null) {
- return new Server(component.getContext().createChildContext(),
Protocol.valueOf(endpoint.getProtocol()), endpoint.getHost(),
endpoint.getPort(), null);
- } else {
- return new Server(component.getContext().createChildContext(),
Protocol.valueOf(endpoint.getProtocol()), endpoint.getPort());
- }
- }
-
- protected String stringArrayToString(String[] strings) {
- StringBuffer result = new StringBuffer();
- for (String str : strings) {
- result.append(str);
- result.append(" ");
+ protected void addServerIfNecessary(RestletEndpoint endpoint) throws
Exception {
+ String key = buildKey(endpoint);
+ RestletHost host;
+ synchronized (restletHostRegistry) {
+ host = restletHostRegistry.get(key);
+ if (host == null) {
+ host = createRestletHost();
+ host.configure(endpoint, component);
+
+ restletHostRegistry.put(key, host);
+ LOG.debug("Added host: {}", key);
+ host.start();
+ }
}
- return result.toString();
}
- protected void setupServerWithSSLContext(Series<Parameter> params,
SSLContextParameters scp) throws GeneralSecurityException, IOException {
- // set the SSLContext parameters
- params.add("sslContextFactory",
- "org.restlet.engine.ssl.DefaultSslContextFactory");
+ protected RestletHost createRestletHost() {
+ RestletHostOptions options = new RestletHostOptions();
- SSLContext context = scp.createSSLContext(getCamelContext());
- SSLEngine engine = context.createSSLEngine();
-
- params.add("enabledProtocols",
stringArrayToString(engine.getEnabledProtocols()));
- params.add("enabledCipherSuites",
stringArrayToString(engine.getEnabledCipherSuites()));
-
- if (scp.getSecureSocketProtocol() != null) {
- params.add("protocol", scp.getSecureSocketProtocol());
+ if (getControllerDaemon() != null) {
+ options.setControllerDaemon(getControllerDaemon());
}
- if (scp.getServerParameters() != null &&
scp.getServerParameters().getClientAuthentication() != null) {
- boolean b =
!scp.getServerParameters().getClientAuthentication().equals("NONE");
- params.add("needClientAuthentication", String.valueOf(b));
+ if (getControllerSleepTimeMs() != null) {
+ options.setControllerSleepTimeMs(getControllerSleepTimeMs());
}
- if (scp.getKeyManagers() != null) {
- if (scp.getKeyManagers().getAlgorithm() != null) {
- params.add("keyManagerAlgorithm",
scp.getKeyManagers().getAlgorithm());
- }
- if (scp.getKeyManagers().getKeyPassword() != null) {
- params.add("keyPassword",
scp.getKeyManagers().getKeyPassword());
- }
- if (scp.getKeyManagers().getKeyStore().getResource() != null) {
- params.add("keyStorePath",
scp.getKeyManagers().getKeyStore().getResource());
- }
- if (scp.getKeyManagers().getKeyStore().getPassword() != null) {
- params.add("keyStorePassword",
scp.getKeyManagers().getKeyStore().getPassword());
- }
- if (scp.getKeyManagers().getKeyStore().getType() != null) {
- params.add("keyStoreType",
scp.getKeyManagers().getKeyStore().getType());
- }
+ if (getInboundBufferSize() != null) {
+ options.setInboundBufferSize(getInboundBufferSize());
}
-
- if (scp.getTrustManagers() != null) {
- if (scp.getTrustManagers().getAlgorithm() != null) {
- params.add("trustManagerAlgorithm",
scp.getKeyManagers().getAlgorithm());
- }
- if (scp.getTrustManagers().getKeyStore().getResource() != null) {
- params.add("trustStorePath",
scp.getTrustManagers().getKeyStore().getResource());
- }
- if (scp.getTrustManagers().getKeyStore().getPassword() != null) {
- params.add("trustStorePassword",
scp.getTrustManagers().getKeyStore().getPassword());
- }
- if (scp.getTrustManagers().getKeyStore().getType() != null) {
- params.add("trustStoreType",
scp.getTrustManagers().getKeyStore().getType());
- }
+ if (getMinThreads() != null) {
+ options.setMinThreads(getMinThreads());
}
- }
-
- protected void addServerIfNecessary(RestletEndpoint endpoint) throws
Exception {
- String key = buildKey(endpoint);
- Server server;
- synchronized (servers) {
- server = servers.get(key);
- if (server == null) {
- server = createServer(endpoint);
- component.getServers().add(server);
-
- // Add any Restlet server parameters that were included
- Series<Parameter> params = server.getContext().getParameters();
-
- if ("https".equals(endpoint.getProtocol())) {
- SSLContextParameters scp =
endpoint.getSslContextParameters();
- if (endpoint.getSslContextParameters() == null) {
- throw new InvalidParameterException("Need to specify
the SSLContextParameters option here!");
- }
- setupServerWithSSLContext(params, scp);
- }
-
- if (getControllerDaemon() != null) {
- params.add("controllerDaemon",
getControllerDaemon().toString());
- }
- if (getControllerSleepTimeMs() != null) {
- params.add("controllerSleepTimeMs",
getControllerSleepTimeMs().toString());
- }
- if (getInboundBufferSize() != null) {
- params.add("inboundBufferSize",
getInboundBufferSize().toString());
- }
- if (getMinThreads() != null) {
- params.add("minThreads", getMinThreads().toString());
- }
- if (getMaxThreads() != null) {
- params.add("maxThreads", getMaxThreads().toString());
- }
- if (getLowThreads() != null) {
- params.add("lowThreads", getLowThreads().toString());
- }
- if (getMaxQueued() != null) {
- params.add("maxQueued", getMaxQueued().toString());
- }
- if (getMaxConnectionsPerHost() != null) {
- params.add("maxConnectionsPerHost",
getMaxConnectionsPerHost().toString());
- }
- if (getMaxTotalConnections() != null) {
- params.add("maxTotalConnections",
getMaxTotalConnections().toString());
- }
- if (getOutboundBufferSize() != null) {
- params.add("outboundBufferSize",
getOutboundBufferSize().toString());
- }
- if (getPersistingConnections() != null) {
- params.add("persistingConnections",
getPersistingConnections().toString());
- }
- if (getPipeliningConnections() != null) {
- params.add("pipeliningConnections",
getPipeliningConnections().toString());
- }
- if (getThreadMaxIdleTimeMs() != null) {
- params.add("threadMaxIdleTimeMs",
getThreadMaxIdleTimeMs().toString());
- }
- if (getUseForwardedForHeader() != null) {
- params.add("useForwardedForHeader",
getUseForwardedForHeader().toString());
- }
- if (getReuseAddress() != null) {
- params.add("reuseAddress", getReuseAddress().toString());
- }
-
- LOG.debug("Setting parameters: {} to server: {}", params,
server);
- server.getContext().setParameters(params);
-
- servers.put(key, server);
- LOG.debug("Added server: {}", key);
- server.start();
- }
+ if (getMaxThreads() != null) {
+ options.setMaxThreads(getMaxThreads());
+ }
+ if (getLowThreads() != null) {
+ options.setLowThreads(getLowThreads());
+ }
+ if (getMaxQueued() != null) {
+ options.setMaxQueued(getMaxQueued());
+ }
+ if (getMaxConnectionsPerHost() != null) {
+ options.setMaxConnectionsPerHost(getMaxConnectionsPerHost());
+ }
+ if (getMaxTotalConnections() != null) {
+ options.setMaxTotalConnections(getMaxTotalConnections());
+ }
+ if (getOutboundBufferSize() != null) {
+ options.setOutboundBufferSize(getOutboundBufferSize());
}
+ if (getPersistingConnections() != null) {
+ options.setPersistingConnections(getPersistingConnections());
+ }
+ if (getPipeliningConnections() != null) {
+ options.setPipeliningConnections(getPipeliningConnections());
+ }
+ if (getThreadMaxIdleTimeMs() != null) {
+ options.setThreadMaxIdleTimeMs(getThreadMaxIdleTimeMs());
+ }
+ if (getUseForwardedForHeader() != null) {
+ options.setUseForwardedForHeader(getUseForwardedForHeader());
+ }
+ if (getReuseAddress() != null) {
+ options.setReuseAddress(getReuseAddress());
+ }
+
+ return new DefaultRestletHost(options);
}
private static String buildKey(RestletEndpoint endpoint) {
diff --git
a/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletHost.java
b/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletHost.java
new file mode 100644
index 00000000000..93ad46115d5
--- /dev/null
+++
b/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletHost.java
@@ -0,0 +1,40 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.restlet;
+
+import org.restlet.Component;
+
+/**
+ * A Restlet host abstraction
+ */
+public interface RestletHost {
+
+ /**
+ * Configure the RestletHost using the Camel {@link RestletEndpoint} and
the Restlet {@link Component}
+ */
+ void configure(RestletEndpoint endpoint, Component component);
+
+ /**
+ * Starts the RestletHost
+ */
+ void start() throws Exception;
+
+ /**
+ * Stops the RestletHost
+ */
+ void stop() throws Exception;
+}
diff --git
a/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletHostOptions.java
b/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletHostOptions.java
new file mode 100644
index 00000000000..ed516f2719c
--- /dev/null
+++
b/components/camel-restlet/src/main/java/org/apache/camel/component/restlet/RestletHostOptions.java
@@ -0,0 +1,218 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.component.restlet;
+
+/**
+ * Options to configure on a {@link RestletHost}
+ */
+public final class RestletHostOptions {
+
+ /**
+ * Indicates if the controller thread should be a daemon.
+ */
+ private Boolean controllerDaemon;
+
+ /**
+ * Time for the controller thread to sleep between each control.
+ */
+ private Integer controllerSleepTimeMs;
+
+ /**
+ * Size of the content buffer for receiving messages.
+ */
+ private Integer inboundBufferSize;
+
+ /**
+ * Maximum number of calls that can be queued if there aren’t any worker
thread available to service them.
+ */
+ private Integer maxQueued;
+
+ /**
+ * Maximum number of concurrent connections per host.
+ */
+ private Integer maxConnectionsPerHost;
+
+ /**
+ * Maximum number of worker threads waiting to service requests.
+ */
+ private Integer maxThreads;
+
+ /**
+ * Maximum number of concurrent connections in total.
+ */
+ private Integer maxTotalConnections;
+
+ /**
+ * Minimum number of worker threads waiting to service requests, even if
they are idle.
+ */
+ private Integer minThreads;
+
+ /**
+ * Number of worker threads determining when the connector is considered
overloaded.
+ */
+ private Integer lowThreads;
+
+ /**
+ * Size of the content buffer for sending messages.
+ */
+ private Integer outboundBufferSize;
+
+ /**
+ * Indicates if connections should be kept alive after a call.
+ */
+ private Boolean persistingConnections;
+
+ /**
+ * Indicates if pipelining connections are supported.
+ */
+ private Boolean pipeliningConnections;
+
+ /**
+ * Enable/disable the SO_REUSEADDR socket option. See
java.io.ServerSocket#reuseAddress property for additional details.
+ */
+ private Boolean reuseAddress;
+
+ /**
+ * Time for an idle thread to wait for an operation before being collected.
+ */
+ private Integer threadMaxIdleTimeMs;
+
+ /**
+ * Lookup the "X-Forwarded-For" header supported by popular proxies and
caches and uses it to populate the Request.getClientAddresses() method result.
+ */
+ private Boolean useForwardedForHeader;
+
+ public Boolean getControllerDaemon() {
+ return controllerDaemon;
+ }
+
+ public void setControllerDaemon(Boolean controllerDaemon) {
+ this.controllerDaemon = controllerDaemon;
+ }
+
+ public Integer getControllerSleepTimeMs() {
+ return controllerSleepTimeMs;
+ }
+
+ public void setControllerSleepTimeMs(Integer controllerSleepTimeMs) {
+ this.controllerSleepTimeMs = controllerSleepTimeMs;
+ }
+
+ public Integer getInboundBufferSize() {
+ return inboundBufferSize;
+ }
+
+ public void setInboundBufferSize(Integer inboundBufferSize) {
+ this.inboundBufferSize = inboundBufferSize;
+ }
+
+ public Integer getMaxQueued() {
+ return maxQueued;
+ }
+
+ public void setMaxQueued(Integer maxQueued) {
+ this.maxQueued = maxQueued;
+ }
+
+ public Integer getMaxConnectionsPerHost() {
+ return maxConnectionsPerHost;
+ }
+
+ public void setMaxConnectionsPerHost(Integer maxConnectionsPerHost) {
+ this.maxConnectionsPerHost = maxConnectionsPerHost;
+ }
+
+ public Integer getMaxThreads() {
+ return maxThreads;
+ }
+
+ public void setMaxThreads(Integer maxThreads) {
+ this.maxThreads = maxThreads;
+ }
+
+ public Integer getMaxTotalConnections() {
+ return maxTotalConnections;
+ }
+
+ public void setMaxTotalConnections(Integer maxTotalConnections) {
+ this.maxTotalConnections = maxTotalConnections;
+ }
+
+ public Integer getMinThreads() {
+ return minThreads;
+ }
+
+ public void setMinThreads(Integer minThreads) {
+ this.minThreads = minThreads;
+ }
+
+ public Integer getLowThreads() {
+ return lowThreads;
+ }
+
+ public void setLowThreads(Integer lowThreads) {
+ this.lowThreads = lowThreads;
+ }
+
+ public Integer getOutboundBufferSize() {
+ return outboundBufferSize;
+ }
+
+ public void setOutboundBufferSize(Integer outboundBufferSize) {
+ this.outboundBufferSize = outboundBufferSize;
+ }
+
+ public Boolean getPersistingConnections() {
+ return persistingConnections;
+ }
+
+ public void setPersistingConnections(Boolean persistingConnections) {
+ this.persistingConnections = persistingConnections;
+ }
+
+ public Boolean getPipeliningConnections() {
+ return pipeliningConnections;
+ }
+
+ public void setPipeliningConnections(Boolean pipeliningConnections) {
+ this.pipeliningConnections = pipeliningConnections;
+ }
+
+ public Boolean getReuseAddress() {
+ return reuseAddress;
+ }
+
+ public void setReuseAddress(Boolean reuseAddress) {
+ this.reuseAddress = reuseAddress;
+ }
+
+ public Integer getThreadMaxIdleTimeMs() {
+ return threadMaxIdleTimeMs;
+ }
+
+ public void setThreadMaxIdleTimeMs(Integer threadMaxIdleTimeMs) {
+ this.threadMaxIdleTimeMs = threadMaxIdleTimeMs;
+ }
+
+ public Boolean getUseForwardedForHeader() {
+ return useForwardedForHeader;
+ }
+
+ public void setUseForwardedForHeader(Boolean useForwardedForHeader) {
+ this.useForwardedForHeader = useForwardedForHeader;
+ }
+}
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
> Abstract Restlet server creation
> --------------------------------
>
> Key: CAMEL-12011
> URL: https://issues.apache.org/jira/browse/CAMEL-12011
> Project: Camel
> Issue Type: Improvement
> Components: camel-restlet
> Reporter: James Netherton
> Assignee: James Netherton
> Fix For: 2.21.0
>
>
> I've been wanting to integrate camel-restlet with WildFly-Camel for some
> time. The sticking point has been getting consumers running on WildFly's
> native undertow server.
> Similar to what we did with the Undertow component, I'd like to create some
> abstractions for how the restlet component creates servers. The default
> implementation can create a Restlet server instance and I can provide my own
> implementation for Undertow in WildFly-Camel.
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
