This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/main by this push:
new eb1c767a24d Http stream (#15251)
eb1c767a24d is described below
commit eb1c767a24d037603ac7e2c2062a32706b0c63ec
Author: Claus Ibsen <[email protected]>
AuthorDate: Wed Aug 21 13:17:07 2024 +0200
Http stream (#15251)
CAMEL-20938: http producer with disableStreamCache=true should use the raw
stream as-is
---
.../catalog/components/atmosphere-websocket.json | 2 +-
.../org/apache/camel/catalog/components/http.json | 2 +-
.../org/apache/camel/catalog/components/https.json | 2 +-
.../org/apache/camel/catalog/components/jetty.json | 2 +-
.../apache/camel/catalog/components/servlet.json | 2 +-
.../atmosphere/websocket/atmosphere-websocket.json | 2 +-
.../camel/http/common/HttpCommonEndpoint.java | 9 +-
.../org/apache/camel/component/http/http.json | 2 +-
.../org/apache/camel/component/http/https.json | 2 +-
.../apache/camel/component/http/HttpProducer.java | 16 +-
.../component/http/HttpDisableStreamCacheTest.java | 40 +++--
.../org/apache/camel/component/jetty12/jetty.json | 2 +-
.../apache/camel/component/servlet/servlet.json | 2 +-
.../AtmosphereWebsocketEndpointBuilderFactory.java | 192 ++++++++++-----------
.../endpoint/dsl/HttpEndpointBuilderFactory.java | 64 +++----
.../dsl/JettyHttp12EndpointBuilderFactory.java | 64 +++----
.../dsl/ServletEndpointBuilderFactory.java | 64 +++----
.../kotlin/components/AtmosphereWebsocketUriDsl.kt | 44 ++---
.../apache/camel/kotlin/components/HttpUriDsl.kt | 44 ++---
.../apache/camel/kotlin/components/JettyUriDsl.kt | 44 ++---
.../camel/kotlin/components/ServletUriDsl.kt | 44 ++---
21 files changed, 332 insertions(+), 313 deletions(-)
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/atmosphere-websocket.json
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/atmosphere-websocket.json
index 3d651a88826..7418cbd7a6b 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/atmosphere-websocket.json
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/atmosphere-websocket.json
@@ -46,7 +46,7 @@
"properties": {
"servicePath": { "index": 0, "kind": "path", "displayName": "Service
Path", "group": "common", "label": "", "required": true, "type": "string",
"javaType": "java.lang.String", "deprecated": false, "deprecationNote": "",
"autowired": false, "secret": false, "description": "Name of websocket
endpoint" },
"chunked": { "index": 1, "kind": "parameter", "displayName": "Chunked",
"group": "common", "label": "", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": true, "description": "If this option is false the
Servlet will disable the HTTP streaming and set the content-length header on
the response" },
- "disableStreamCache": { "index": 2, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 2, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"sendToAll": { "index": 3, "kind": "parameter", "displayName": "Send To
All", "group": "common", "label": "", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": false, "description": "Whether to send to all
(broadcast) or send to a single receiver." },
"transferException": { "index": 4, "kind": "parameter", "displayName":
"Transfer Exception", "group": "common", "label": "common", "required": false,
"type": "boolean", "javaType": "boolean", "deprecated": false, "autowired":
false, "secret": false, "defaultValue": false, "description": "If enabled and
an Exchange failed processing on the consumer side, and if the caused Exception
was send back serialized in the response as a
application\/x-java-serialized-object content type. On the [...]
"useStreaming": { "index": 5, "kind": "parameter", "displayName": "Use
Streaming", "group": "common", "label": "", "required": false, "type":
"boolean", "javaType": "boolean", "deprecated": false, "autowired": false,
"secret": false, "defaultValue": false, "description": "To enable streaming to
send data as multiple text fragments." },
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/http.json
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/http.json
index 9b5dd2b8c72..4e5182edbb7 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/http.json
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/http.json
@@ -85,7 +85,7 @@
},
"properties": {
"httpUri": { "index": 0, "kind": "path", "displayName": "Http Uri",
"group": "common", "label": "common", "required": true, "type": "string",
"javaType": "java.net.URI", "deprecated": false, "deprecationNote": "",
"autowired": false, "secret": false, "description": "The url of the HTTP
endpoint to call." },
- "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"headerFilterStrategy": { "index": 2, "kind": "parameter", "displayName":
"Header Filter Strategy", "group": "common (advanced)", "label":
"common,advanced", "required": false, "type": "object", "javaType":
"org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HeaderFilterStrategy to
filter header to and from Camel message." },
"bridgeEndpoint": { "index": 3, "kind": "parameter", "displayName":
"Bridge Endpoint", "group": "producer", "label": "producer", "required": false,
"type": "boolean", "javaType": "boolean", "deprecated": false, "autowired":
false, "secret": false, "defaultValue": false, "description": "If the option is
true, HttpProducer will ignore the Exchange.HTTP_URI header, and use the
endpoint's URI for request. You may also set the option throwExceptionOnFailure
to be false to let the HttpProd [...]
"connectionClose": { "index": 4, "kind": "parameter", "displayName":
"Connection Close", "group": "producer", "label": "producer", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Specifies whether a Connection Close header must be added to HTTP Request. By
default connectionClose is false." },
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/https.json
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/https.json
index 51879cd6e15..ec0629e58e0 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/https.json
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/https.json
@@ -85,7 +85,7 @@
},
"properties": {
"httpUri": { "index": 0, "kind": "path", "displayName": "Http Uri",
"group": "common", "label": "common", "required": true, "type": "string",
"javaType": "java.net.URI", "deprecated": false, "deprecationNote": "",
"autowired": false, "secret": false, "description": "The url of the HTTP
endpoint to call." },
- "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"headerFilterStrategy": { "index": 2, "kind": "parameter", "displayName":
"Header Filter Strategy", "group": "common (advanced)", "label":
"common,advanced", "required": false, "type": "object", "javaType":
"org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HeaderFilterStrategy to
filter header to and from Camel message." },
"bridgeEndpoint": { "index": 3, "kind": "parameter", "displayName":
"Bridge Endpoint", "group": "producer", "label": "producer", "required": false,
"type": "boolean", "javaType": "boolean", "deprecated": false, "autowired":
false, "secret": false, "defaultValue": false, "description": "If the option is
true, HttpProducer will ignore the Exchange.HTTP_URI header, and use the
endpoint's URI for request. You may also set the option throwExceptionOnFailure
to be false to let the HttpProd [...]
"connectionClose": { "index": 4, "kind": "parameter", "displayName":
"Connection Close", "group": "producer", "label": "producer", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Specifies whether a Connection Close header must be added to HTTP Request. By
default connectionClose is false." },
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/jetty.json
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/jetty.json
index dd13397fbf5..b04fc02525e 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/jetty.json
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/jetty.json
@@ -70,7 +70,7 @@
"headerFilterStrategy": { "index": 1, "kind": "parameter", "displayName":
"Header Filter Strategy", "group": "common (advanced)", "label":
"common,advanced", "required": false, "type": "object", "javaType":
"org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HeaderFilterStrategy to
filter header to and from Camel message." },
"httpBinding": { "index": 2, "kind": "parameter", "displayName": "Http
Binding", "group": "common (advanced)", "label": "common,advanced", "required":
false, "type": "object", "javaType":
"org.apache.camel.http.common.HttpBinding", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HttpBinding to control
the mapping between Camel message and HttpClient." },
"chunked": { "index": 3, "kind": "parameter", "displayName": "Chunked",
"group": "consumer", "label": "", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": true, "description": "If this option is false the
Servlet will disable the HTTP streaming and set the content-length header on
the response" },
- "disableStreamCache": { "index": 4, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 4, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"transferException": { "index": 5, "kind": "parameter", "displayName":
"Transfer Exception", "group": "common", "label": "common", "required": false,
"type": "boolean", "javaType": "boolean", "deprecated": false, "autowired":
false, "secret": false, "defaultValue": false, "description": "If enabled and
an Exchange failed processing on the consumer side, and if the caused Exception
was send back serialized in the response as a
application\/x-java-serialized-object content type. On the [...]
"async": { "index": 6, "kind": "parameter", "displayName": "Async",
"group": "consumer", "label": "consumer", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": false, "description": "Configure the consumer to work in
async mode" },
"continuationTimeout": { "index": 7, "kind": "parameter", "displayName":
"Continuation Timeout", "group": "consumer", "label": "consumer", "required":
false, "type": "integer", "javaType": "java.lang.Long", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": "30000", "description":
"Allows to set a timeout in millis when using Jetty as consumer (server). By
default Jetty uses 30000. You can use a value of = 0 to never expire. If a
timeout occurs then the request [...]
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/servlet.json
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/servlet.json
index ab31c9512f6..dc3255f728a 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/servlet.json
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/servlet.json
@@ -38,7 +38,7 @@
},
"properties": {
"contextPath": { "index": 0, "kind": "path", "displayName": "Context
Path", "group": "consumer", "label": "consumer", "required": true, "type":
"string", "javaType": "java.lang.String", "deprecated": false,
"deprecationNote": "", "autowired": false, "secret": false, "description": "The
context-path to use" },
- "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"headerFilterStrategy": { "index": 2, "kind": "parameter", "displayName":
"Header Filter Strategy", "group": "common (advanced)", "label":
"common,advanced", "required": false, "type": "object", "javaType":
"org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HeaderFilterStrategy to
filter header to and from Camel message." },
"httpBinding": { "index": 3, "kind": "parameter", "displayName": "Http
Binding", "group": "common (advanced)", "label": "common,advanced", "required":
false, "type": "object", "javaType":
"org.apache.camel.http.common.HttpBinding", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HttpBinding to control
the mapping between Camel message and HttpClient." },
"chunked": { "index": 4, "kind": "parameter", "displayName": "Chunked",
"group": "consumer", "label": "", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": true, "description": "If this option is false the
Servlet will disable the HTTP streaming and set the content-length header on
the response" },
diff --git
a/components/camel-atmosphere-websocket/src/generated/resources/META-INF/org/apache/camel/component/atmosphere/websocket/atmosphere-websocket.json
b/components/camel-atmosphere-websocket/src/generated/resources/META-INF/org/apache/camel/component/atmosphere/websocket/atmosphere-websocket.json
index 3d651a88826..7418cbd7a6b 100644
---
a/components/camel-atmosphere-websocket/src/generated/resources/META-INF/org/apache/camel/component/atmosphere/websocket/atmosphere-websocket.json
+++
b/components/camel-atmosphere-websocket/src/generated/resources/META-INF/org/apache/camel/component/atmosphere/websocket/atmosphere-websocket.json
@@ -46,7 +46,7 @@
"properties": {
"servicePath": { "index": 0, "kind": "path", "displayName": "Service
Path", "group": "common", "label": "", "required": true, "type": "string",
"javaType": "java.lang.String", "deprecated": false, "deprecationNote": "",
"autowired": false, "secret": false, "description": "Name of websocket
endpoint" },
"chunked": { "index": 1, "kind": "parameter", "displayName": "Chunked",
"group": "common", "label": "", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": true, "description": "If this option is false the
Servlet will disable the HTTP streaming and set the content-length header on
the response" },
- "disableStreamCache": { "index": 2, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 2, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"sendToAll": { "index": 3, "kind": "parameter", "displayName": "Send To
All", "group": "common", "label": "", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": false, "description": "Whether to send to all
(broadcast) or send to a single receiver." },
"transferException": { "index": 4, "kind": "parameter", "displayName":
"Transfer Exception", "group": "common", "label": "common", "required": false,
"type": "boolean", "javaType": "boolean", "deprecated": false, "autowired":
false, "secret": false, "defaultValue": false, "description": "If enabled and
an Exchange failed processing on the consumer side, and if the caused Exception
was send back serialized in the response as a
application\/x-java-serialized-object content type. On the [...]
"useStreaming": { "index": 5, "kind": "parameter", "displayName": "Use
Streaming", "group": "common", "label": "", "required": false, "type":
"boolean", "javaType": "boolean", "deprecated": false, "autowired": false,
"secret": false, "defaultValue": false, "description": "To enable streaming to
send data as multiple text fragments." },
diff --git
a/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpCommonEndpoint.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpCommonEndpoint.java
index cddef8cb34d..7ad028318c3 100644
---
a/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpCommonEndpoint.java
+++
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpCommonEndpoint.java
@@ -67,17 +67,16 @@ public abstract class HttpCommonEndpoint extends
DefaultEndpoint
description = "If this option is false the Servlet will disable
the HTTP streaming and set the content-length header on the response")
boolean chunked = true;
@UriParam(label = "common",
- description = "Determines whether or not the raw input stream
from Servlet is cached or not"
- + " (Camel will read the stream into a in
memory/overflow to file, Stream caching) cache."
- + " By default Camel will cache the Servlet input
stream to support reading it multiple times to ensure it Camel"
+ description = "Determines whether or not the raw input stream is
cached or not."
+ + " The Camel consumer (camel-servlet, camel-jetty
etc.) will by default cache the input stream to support reading it multiple
times to ensure it Camel"
+ " can retrieve all data from the stream. However
you can set this option to true when you for example need"
+ " to access the raw stream, such as streaming it
directly to a file or other persistent store."
+ " DefaultHttpBinding will copy the request input
stream into a stream cache and put it into message body"
+ " if this option is false to support reading the
stream multiple times."
+ " If you use Servlet to bridge/proxy an endpoint
then consider enabling this option to improve performance,"
+ " in case you do not need to read the message
payload multiple times."
- + " The http producer will by default cache the
response body stream. If setting this option to true,"
- + " then the producers will not cache the response
body stream but use the response stream as-is as the message body.")
+ + " The producer (camel-http) will by default
cache the response body stream. If setting this option to true,"
+ + " then the producers will not cache the response
body stream but use the response stream as-is (the stream can only be read
once) as the message body.")
boolean disableStreamCache;
@UriParam(label = "common",
description = "If enabled and an Exchange failed processing on
the consumer side, and if the caused Exception was send back serialized"
diff --git
a/components/camel-http/src/generated/resources/META-INF/org/apache/camel/component/http/http.json
b/components/camel-http/src/generated/resources/META-INF/org/apache/camel/component/http/http.json
index 9b5dd2b8c72..4e5182edbb7 100644
---
a/components/camel-http/src/generated/resources/META-INF/org/apache/camel/component/http/http.json
+++
b/components/camel-http/src/generated/resources/META-INF/org/apache/camel/component/http/http.json
@@ -85,7 +85,7 @@
},
"properties": {
"httpUri": { "index": 0, "kind": "path", "displayName": "Http Uri",
"group": "common", "label": "common", "required": true, "type": "string",
"javaType": "java.net.URI", "deprecated": false, "deprecationNote": "",
"autowired": false, "secret": false, "description": "The url of the HTTP
endpoint to call." },
- "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"headerFilterStrategy": { "index": 2, "kind": "parameter", "displayName":
"Header Filter Strategy", "group": "common (advanced)", "label":
"common,advanced", "required": false, "type": "object", "javaType":
"org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HeaderFilterStrategy to
filter header to and from Camel message." },
"bridgeEndpoint": { "index": 3, "kind": "parameter", "displayName":
"Bridge Endpoint", "group": "producer", "label": "producer", "required": false,
"type": "boolean", "javaType": "boolean", "deprecated": false, "autowired":
false, "secret": false, "defaultValue": false, "description": "If the option is
true, HttpProducer will ignore the Exchange.HTTP_URI header, and use the
endpoint's URI for request. You may also set the option throwExceptionOnFailure
to be false to let the HttpProd [...]
"connectionClose": { "index": 4, "kind": "parameter", "displayName":
"Connection Close", "group": "producer", "label": "producer", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Specifies whether a Connection Close header must be added to HTTP Request. By
default connectionClose is false." },
diff --git
a/components/camel-http/src/generated/resources/META-INF/org/apache/camel/component/http/https.json
b/components/camel-http/src/generated/resources/META-INF/org/apache/camel/component/http/https.json
index 51879cd6e15..ec0629e58e0 100644
---
a/components/camel-http/src/generated/resources/META-INF/org/apache/camel/component/http/https.json
+++
b/components/camel-http/src/generated/resources/META-INF/org/apache/camel/component/http/https.json
@@ -85,7 +85,7 @@
},
"properties": {
"httpUri": { "index": 0, "kind": "path", "displayName": "Http Uri",
"group": "common", "label": "common", "required": true, "type": "string",
"javaType": "java.net.URI", "deprecated": false, "deprecationNote": "",
"autowired": false, "secret": false, "description": "The url of the HTTP
endpoint to call." },
- "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"headerFilterStrategy": { "index": 2, "kind": "parameter", "displayName":
"Header Filter Strategy", "group": "common (advanced)", "label":
"common,advanced", "required": false, "type": "object", "javaType":
"org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HeaderFilterStrategy to
filter header to and from Camel message." },
"bridgeEndpoint": { "index": 3, "kind": "parameter", "displayName":
"Bridge Endpoint", "group": "producer", "label": "producer", "required": false,
"type": "boolean", "javaType": "boolean", "deprecated": false, "autowired":
false, "secret": false, "defaultValue": false, "description": "If the option is
true, HttpProducer will ignore the Exchange.HTTP_URI header, and use the
endpoint's URI for request. You may also set the option throwExceptionOnFailure
to be false to let the HttpProd [...]
"connectionClose": { "index": 4, "kind": "parameter", "displayName":
"Connection Close", "group": "producer", "label": "producer", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Specifies whether a Connection Close header must be added to HTTP Request. By
default connectionClose is false." },
diff --git
a/components/camel-http/src/main/java/org/apache/camel/component/http/HttpProducer.java
b/components/camel-http/src/main/java/org/apache/camel/component/http/HttpProducer.java
index b8386a1b277..4004e680800 100644
---
a/components/camel-http/src/main/java/org/apache/camel/component/http/HttpProducer.java
+++
b/components/camel-http/src/main/java/org/apache/camel/component/http/HttpProducer.java
@@ -474,12 +474,16 @@ public class HttpProducer extends DefaultProducer {
* @throws IOException can be thrown
*/
protected <T> T executeMethod(HttpHost httpHost, HttpUriRequest
httpRequest, HttpClientResponseHandler<T> handler)
- throws IOException {
- HttpContext localContext = HttpClientContext.create();
+ throws IOException, HttpException {
+ HttpContext localContext;
if (httpContext != null) {
localContext = new BasicHttpContext(httpContext);
+ } else {
+ localContext = HttpClientContext.create();
}
- return httpClient.execute(httpHost, httpRequest, localContext,
handler);
+ // execute open that does not automatic close response input-stream
(this is done in exchange on-completion by Camel)
+ ClassicHttpResponse res = httpClient.executeOpen(httpHost,
httpRequest, localContext);
+ return handler.handleResponse(res);
}
/**
@@ -550,10 +554,8 @@ public class HttpProducer extends DefaultProducer {
} else {
if (entity.isStreaming()) {
if (getEndpoint().isDisableStreamCache()) {
- // write to in-memory buffer
- ByteArrayOutputStream bos = new
ByteArrayOutputStream(BUFFER_SIZE);
- entity.writeTo(bos);
- return bos.toByteArray();
+ // use the response as-is
+ return is;
} else {
int max =
getEndpoint().getComponent().getResponsePayloadStreamingThreshold();
if (max > 0) {
diff --git
a/components/camel-http/src/test/java/org/apache/camel/component/http/HttpDisableStreamCacheTest.java
b/components/camel-http/src/test/java/org/apache/camel/component/http/HttpDisableStreamCacheTest.java
index 19cb4595405..daa89f482d3 100644
---
a/components/camel-http/src/test/java/org/apache/camel/component/http/HttpDisableStreamCacheTest.java
+++
b/components/camel-http/src/test/java/org/apache/camel/component/http/HttpDisableStreamCacheTest.java
@@ -16,14 +16,18 @@
*/
package org.apache.camel.component.http;
-import org.apache.camel.Exchange;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+
+import org.apache.camel.RoutesBuilder;
+import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.http.handler.BasicValidationHandler;
+import org.apache.camel.util.IOHelper;
import org.apache.hc.core5.http.impl.bootstrap.HttpServer;
import org.apache.hc.core5.http.impl.bootstrap.ServerBootstrap;
import org.junit.jupiter.api.Test;
import static org.apache.camel.http.common.HttpMethods.GET;
-import static org.apache.camel.test.junit5.TestSupport.assertIsInstanceOf;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -42,7 +46,6 @@ public class HttpDisableStreamCacheTest extends BaseHttpTest {
@Override
public void cleanupResources() throws Exception {
-
if (localServer != null) {
localServer.stop();
}
@@ -50,15 +53,30 @@ public class HttpDisableStreamCacheTest extends
BaseHttpTest {
@Test
public void httpDisableStreamCache() {
- Exchange exchange = template.request("http://localhost:";
- + localServer.getLocalPort() +
"/test/?disableStreamCache=true",
- exchange1 -> {
- });
+ Object out = template.requestBody("direct:start", (String) null);
+ assertEquals("camel rocks!",
context.getTypeConverter().convertTo(String.class, out));
+ }
- byte[] arr = assertIsInstanceOf(byte[].class,
exchange.getMessage().getBody());
- assertNotNull(arr);
+ @Override
+ protected RoutesBuilder createRouteBuilder() throws Exception {
+ return new RouteBuilder() {
+ @Override
+ public void configure() throws Exception {
+ from("direct:start").streamCache("false")
+ .to("http://localhost:"; + localServer.getLocalPort() +
"/test/?disableStreamCache=true")
+ .process(e -> {
+ InputStream is = (InputStream)
e.getMessage().getBody();
+ assertNotNull(is);
- assertEquals("camel rocks!",
context.getTypeConverter().convertTo(String.class, arr));
- }
+ // we can only read the raw http stream once
+ ByteArrayOutputStream bos = new
ByteArrayOutputStream();
+ IOHelper.copy(is, bos);
+
+ e.setVariable("newBody", bos.toString());
+ })
+ .setBody().variable("newBody");
+ }
+ };
+ }
}
diff --git
a/components/camel-jetty/src/generated/resources/META-INF/org/apache/camel/component/jetty12/jetty.json
b/components/camel-jetty/src/generated/resources/META-INF/org/apache/camel/component/jetty12/jetty.json
index dd13397fbf5..b04fc02525e 100644
---
a/components/camel-jetty/src/generated/resources/META-INF/org/apache/camel/component/jetty12/jetty.json
+++
b/components/camel-jetty/src/generated/resources/META-INF/org/apache/camel/component/jetty12/jetty.json
@@ -70,7 +70,7 @@
"headerFilterStrategy": { "index": 1, "kind": "parameter", "displayName":
"Header Filter Strategy", "group": "common (advanced)", "label":
"common,advanced", "required": false, "type": "object", "javaType":
"org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HeaderFilterStrategy to
filter header to and from Camel message." },
"httpBinding": { "index": 2, "kind": "parameter", "displayName": "Http
Binding", "group": "common (advanced)", "label": "common,advanced", "required":
false, "type": "object", "javaType":
"org.apache.camel.http.common.HttpBinding", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HttpBinding to control
the mapping between Camel message and HttpClient." },
"chunked": { "index": 3, "kind": "parameter", "displayName": "Chunked",
"group": "consumer", "label": "", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": true, "description": "If this option is false the
Servlet will disable the HTTP streaming and set the content-length header on
the response" },
- "disableStreamCache": { "index": 4, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 4, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"transferException": { "index": 5, "kind": "parameter", "displayName":
"Transfer Exception", "group": "common", "label": "common", "required": false,
"type": "boolean", "javaType": "boolean", "deprecated": false, "autowired":
false, "secret": false, "defaultValue": false, "description": "If enabled and
an Exchange failed processing on the consumer side, and if the caused Exception
was send back serialized in the response as a
application\/x-java-serialized-object content type. On the [...]
"async": { "index": 6, "kind": "parameter", "displayName": "Async",
"group": "consumer", "label": "consumer", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": false, "description": "Configure the consumer to work in
async mode" },
"continuationTimeout": { "index": 7, "kind": "parameter", "displayName":
"Continuation Timeout", "group": "consumer", "label": "consumer", "required":
false, "type": "integer", "javaType": "java.lang.Long", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": "30000", "description":
"Allows to set a timeout in millis when using Jetty as consumer (server). By
default Jetty uses 30000. You can use a value of = 0 to never expire. If a
timeout occurs then the request [...]
diff --git
a/components/camel-servlet/src/generated/resources/META-INF/org/apache/camel/component/servlet/servlet.json
b/components/camel-servlet/src/generated/resources/META-INF/org/apache/camel/component/servlet/servlet.json
index ab31c9512f6..dc3255f728a 100644
---
a/components/camel-servlet/src/generated/resources/META-INF/org/apache/camel/component/servlet/servlet.json
+++
b/components/camel-servlet/src/generated/resources/META-INF/org/apache/camel/component/servlet/servlet.json
@@ -38,7 +38,7 @@
},
"properties": {
"contextPath": { "index": 0, "kind": "path", "displayName": "Context
Path", "group": "consumer", "label": "consumer", "required": true, "type":
"string", "javaType": "java.lang.String", "deprecated": false,
"deprecationNote": "", "autowired": false, "secret": false, "description": "The
context-path to use" },
- "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream from Servlet is cached or not
(Camel will read the stream into a in memory\/overflow to file, Stream caching)
cache. By default Camel will cache the [...]
+ "disableStreamCache": { "index": 1, "kind": "parameter", "displayName":
"Disable Stream Cache", "group": "common", "label": "common", "required":
false, "type": "boolean", "javaType": "boolean", "deprecated": false,
"autowired": false, "secret": false, "defaultValue": false, "description":
"Determines whether or not the raw input stream is cached or not. The Camel
consumer (camel-servlet, camel-jetty etc.) will by default cache the input
stream to support reading it multiple times to [...]
"headerFilterStrategy": { "index": 2, "kind": "parameter", "displayName":
"Header Filter Strategy", "group": "common (advanced)", "label":
"common,advanced", "required": false, "type": "object", "javaType":
"org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HeaderFilterStrategy to
filter header to and from Camel message." },
"httpBinding": { "index": 3, "kind": "parameter", "displayName": "Http
Binding", "group": "common (advanced)", "label": "common,advanced", "required":
false, "type": "object", "javaType":
"org.apache.camel.http.common.HttpBinding", "deprecated": false, "autowired":
false, "secret": false, "description": "To use a custom HttpBinding to control
the mapping between Camel message and HttpClient." },
"chunked": { "index": 4, "kind": "parameter", "displayName": "Chunked",
"group": "consumer", "label": "", "required": false, "type": "boolean",
"javaType": "boolean", "deprecated": false, "autowired": false, "secret":
false, "defaultValue": true, "description": "If this option is false the
Servlet will disable the HTTP streaming and set the content-length header on
the response" },
diff --git
a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/AtmosphereWebsocketEndpointBuilderFactory.java
b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/AtmosphereWebsocketEndpointBuilderFactory.java
index 3a69ba313a0..8ee72b517e7 100644
---
a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/AtmosphereWebsocketEndpointBuilderFactory.java
+++
b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/AtmosphereWebsocketEndpointBuilderFactory.java
@@ -76,22 +76,22 @@ public interface AtmosphereWebsocketEndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option is a: <code>boolean</code> type.
*
@@ -106,22 +106,22 @@ public interface
AtmosphereWebsocketEndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -922,22 +922,22 @@ public interface
AtmosphereWebsocketEndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option is a: <code>boolean</code> type.
*
@@ -952,22 +952,22 @@ public interface
AtmosphereWebsocketEndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -1289,22 +1289,22 @@ public interface
AtmosphereWebsocketEndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option is a: <code>boolean</code> type.
*
@@ -1319,22 +1319,22 @@ public interface
AtmosphereWebsocketEndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option will be converted to a <code>boolean</code> type.
*
diff --git
a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/HttpEndpointBuilderFactory.java
b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/HttpEndpointBuilderFactory.java
index ce7798d485e..deccba69442 100644
---
a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/HttpEndpointBuilderFactory.java
+++
b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/HttpEndpointBuilderFactory.java
@@ -45,22 +45,22 @@ public interface HttpEndpointBuilderFactory {
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option is a: <code>boolean</code> type.
*
@@ -75,22 +75,22 @@ public interface HttpEndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option will be converted to a <code>boolean</code> type.
*
diff --git
a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/JettyHttp12EndpointBuilderFactory.java
b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/JettyHttp12EndpointBuilderFactory.java
index de8364df2c0..ff4f101eca2 100644
---
a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/JettyHttp12EndpointBuilderFactory.java
+++
b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/JettyHttp12EndpointBuilderFactory.java
@@ -77,22 +77,22 @@ public interface JettyHttp12EndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option is a: <code>boolean</code> type.
*
@@ -107,22 +107,22 @@ public interface JettyHttp12EndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option will be converted to a <code>boolean</code> type.
*
diff --git
a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/ServletEndpointBuilderFactory.java
b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/ServletEndpointBuilderFactory.java
index 640153900a1..0c1ff9761f6 100644
---
a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/ServletEndpointBuilderFactory.java
+++
b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/ServletEndpointBuilderFactory.java
@@ -45,22 +45,22 @@ public interface ServletEndpointBuilderFactory {
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option is a: <code>boolean</code> type.
*
@@ -75,22 +75,22 @@ public interface ServletEndpointBuilderFactory {
return this;
}
/**
- * Determines whether or not the raw input stream from Servlet is
cached
- * or not (Camel will read the stream into a in memory/overflow to
file,
- * Stream caching) cache. By default Camel will cache the Servlet input
- * stream to support reading it multiple times to ensure it Camel can
- * retrieve all data from the stream. However you can set this option
to
- * true when you for example need to access the raw stream, such as
- * streaming it directly to a file or other persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream
- * cache and put it into message body if this option is false to
support
- * reading the stream multiple times. If you use Servlet to
bridge/proxy
- * an endpoint then consider enabling this option to improve
- * performance, in case you do not need to read the message payload
- * multiple times. The http producer will by default cache the response
- * body stream. If setting this option to true, then the producers will
- * not cache the response body stream but use the response stream as-is
- * as the message body.
+ * Determines whether or not the raw input stream is cached or not. The
+ * Camel consumer (camel-servlet, camel-jetty etc.) will by default
+ * cache the input stream to support reading it multiple times to
ensure
+ * it Camel can retrieve all data from the stream. However you can set
+ * this option to true when you for example need to access the raw
+ * stream, such as streaming it directly to a file or other persistent
+ * store. DefaultHttpBinding will copy the request input stream into a
+ * stream cache and put it into message body if this option is false to
+ * support reading the stream multiple times. If you use Servlet to
+ * bridge/proxy an endpoint then consider enabling this option to
+ * improve performance, in case you do not need to read the message
+ * payload multiple times. The producer (camel-http) will by default
+ * cache the response body stream. If setting this option to true, then
+ * the producers will not cache the response body stream but use the
+ * response stream as-is (the stream can only be read once) as the
+ * message body.
*
* The option will be converted to a <code>boolean</code> type.
*
diff --git
a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/AtmosphereWebsocketUriDsl.kt
b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/AtmosphereWebsocketUriDsl.kt
index 249bb879784..9ca14185678 100644
---
a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/AtmosphereWebsocketUriDsl.kt
+++
b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/AtmosphereWebsocketUriDsl.kt
@@ -68,34 +68,34 @@ public class AtmosphereWebsocketUriDsl(
}
/**
- * Determines whether or not the raw input stream from Servlet is cached or
not (Camel will read
- * the stream into a in memory/overflow to file, Stream caching) cache. By
default Camel will cache
- * the Servlet input stream to support reading it multiple times to ensure
it Camel can retrieve all
- * data from the stream. However you can set this option to true when you
for example need to access
- * the raw stream, such as streaming it directly to a file or other
persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream cache
and put it into message
- * body if this option is false to support reading the stream multiple
times. If you use Servlet to
- * bridge/proxy an endpoint then consider enabling this option to improve
performance, in case you do
- * not need to read the message payload multiple times. The http producer
will by default cache the
- * response body stream. If setting this option to true, then the producers
will not cache the
- * response body stream but use the response stream as-is as the message
body.
+ * Determines whether or not the raw input stream is cached or not. The
Camel consumer
+ * (camel-servlet, camel-jetty etc.) will by default cache the input stream
to support reading it
+ * multiple times to ensure it Camel can retrieve all data from the stream.
However you can set this
+ * option to true when you for example need to access the raw stream, such
as streaming it directly
+ * to a file or other persistent store. DefaultHttpBinding will copy the
request input stream into a
+ * stream cache and put it into message body if this option is false to
support reading the stream
+ * multiple times. If you use Servlet to bridge/proxy an endpoint then
consider enabling this option
+ * to improve performance, in case you do not need to read the message
payload multiple times. The
+ * producer (camel-http) will by default cache the response body stream. If
setting this option to
+ * true, then the producers will not cache the response body stream but use
the response stream as-is
+ * (the stream can only be read once) as the message body.
*/
public fun disableStreamCache(disableStreamCache: String) {
it.property("disableStreamCache", disableStreamCache)
}
/**
- * Determines whether or not the raw input stream from Servlet is cached or
not (Camel will read
- * the stream into a in memory/overflow to file, Stream caching) cache. By
default Camel will cache
- * the Servlet input stream to support reading it multiple times to ensure
it Camel can retrieve all
- * data from the stream. However you can set this option to true when you
for example need to access
- * the raw stream, such as streaming it directly to a file or other
persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream cache
and put it into message
- * body if this option is false to support reading the stream multiple
times. If you use Servlet to
- * bridge/proxy an endpoint then consider enabling this option to improve
performance, in case you do
- * not need to read the message payload multiple times. The http producer
will by default cache the
- * response body stream. If setting this option to true, then the producers
will not cache the
- * response body stream but use the response stream as-is as the message
body.
+ * Determines whether or not the raw input stream is cached or not. The
Camel consumer
+ * (camel-servlet, camel-jetty etc.) will by default cache the input stream
to support reading it
+ * multiple times to ensure it Camel can retrieve all data from the stream.
However you can set this
+ * option to true when you for example need to access the raw stream, such
as streaming it directly
+ * to a file or other persistent store. DefaultHttpBinding will copy the
request input stream into a
+ * stream cache and put it into message body if this option is false to
support reading the stream
+ * multiple times. If you use Servlet to bridge/proxy an endpoint then
consider enabling this option
+ * to improve performance, in case you do not need to read the message
payload multiple times. The
+ * producer (camel-http) will by default cache the response body stream. If
setting this option to
+ * true, then the producers will not cache the response body stream but use
the response stream as-is
+ * (the stream can only be read once) as the message body.
*/
public fun disableStreamCache(disableStreamCache: Boolean) {
it.property("disableStreamCache", disableStreamCache.toString())
diff --git
a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/HttpUriDsl.kt
b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/HttpUriDsl.kt
index a1283611219..17616904b2f 100644
---
a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/HttpUriDsl.kt
+++
b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/HttpUriDsl.kt
@@ -52,34 +52,34 @@ public class HttpUriDsl(
}
/**
- * Determines whether or not the raw input stream from Servlet is cached or
not (Camel will read
- * the stream into a in memory/overflow to file, Stream caching) cache. By
default Camel will cache
- * the Servlet input stream to support reading it multiple times to ensure
it Camel can retrieve all
- * data from the stream. However you can set this option to true when you
for example need to access
- * the raw stream, such as streaming it directly to a file or other
persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream cache
and put it into message
- * body if this option is false to support reading the stream multiple
times. If you use Servlet to
- * bridge/proxy an endpoint then consider enabling this option to improve
performance, in case you do
- * not need to read the message payload multiple times. The http producer
will by default cache the
- * response body stream. If setting this option to true, then the producers
will not cache the
- * response body stream but use the response stream as-is as the message
body.
+ * Determines whether or not the raw input stream is cached or not. The
Camel consumer
+ * (camel-servlet, camel-jetty etc.) will by default cache the input stream
to support reading it
+ * multiple times to ensure it Camel can retrieve all data from the stream.
However you can set this
+ * option to true when you for example need to access the raw stream, such
as streaming it directly
+ * to a file or other persistent store. DefaultHttpBinding will copy the
request input stream into a
+ * stream cache and put it into message body if this option is false to
support reading the stream
+ * multiple times. If you use Servlet to bridge/proxy an endpoint then
consider enabling this option
+ * to improve performance, in case you do not need to read the message
payload multiple times. The
+ * producer (camel-http) will by default cache the response body stream. If
setting this option to
+ * true, then the producers will not cache the response body stream but use
the response stream as-is
+ * (the stream can only be read once) as the message body.
*/
public fun disableStreamCache(disableStreamCache: String) {
it.property("disableStreamCache", disableStreamCache)
}
/**
- * Determines whether or not the raw input stream from Servlet is cached or
not (Camel will read
- * the stream into a in memory/overflow to file, Stream caching) cache. By
default Camel will cache
- * the Servlet input stream to support reading it multiple times to ensure
it Camel can retrieve all
- * data from the stream. However you can set this option to true when you
for example need to access
- * the raw stream, such as streaming it directly to a file or other
persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream cache
and put it into message
- * body if this option is false to support reading the stream multiple
times. If you use Servlet to
- * bridge/proxy an endpoint then consider enabling this option to improve
performance, in case you do
- * not need to read the message payload multiple times. The http producer
will by default cache the
- * response body stream. If setting this option to true, then the producers
will not cache the
- * response body stream but use the response stream as-is as the message
body.
+ * Determines whether or not the raw input stream is cached or not. The
Camel consumer
+ * (camel-servlet, camel-jetty etc.) will by default cache the input stream
to support reading it
+ * multiple times to ensure it Camel can retrieve all data from the stream.
However you can set this
+ * option to true when you for example need to access the raw stream, such
as streaming it directly
+ * to a file or other persistent store. DefaultHttpBinding will copy the
request input stream into a
+ * stream cache and put it into message body if this option is false to
support reading the stream
+ * multiple times. If you use Servlet to bridge/proxy an endpoint then
consider enabling this option
+ * to improve performance, in case you do not need to read the message
payload multiple times. The
+ * producer (camel-http) will by default cache the response body stream. If
setting this option to
+ * true, then the producers will not cache the response body stream but use
the response stream as-is
+ * (the stream can only be read once) as the message body.
*/
public fun disableStreamCache(disableStreamCache: Boolean) {
it.property("disableStreamCache", disableStreamCache.toString())
diff --git
a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/JettyUriDsl.kt
b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/JettyUriDsl.kt
index f8c621a97b1..36a197852ba 100644
---
a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/JettyUriDsl.kt
+++
b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/JettyUriDsl.kt
@@ -82,34 +82,34 @@ public class JettyUriDsl(
}
/**
- * Determines whether or not the raw input stream from Servlet is cached or
not (Camel will read
- * the stream into a in memory/overflow to file, Stream caching) cache. By
default Camel will cache
- * the Servlet input stream to support reading it multiple times to ensure
it Camel can retrieve all
- * data from the stream. However you can set this option to true when you
for example need to access
- * the raw stream, such as streaming it directly to a file or other
persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream cache
and put it into message
- * body if this option is false to support reading the stream multiple
times. If you use Servlet to
- * bridge/proxy an endpoint then consider enabling this option to improve
performance, in case you do
- * not need to read the message payload multiple times. The http producer
will by default cache the
- * response body stream. If setting this option to true, then the producers
will not cache the
- * response body stream but use the response stream as-is as the message
body.
+ * Determines whether or not the raw input stream is cached or not. The
Camel consumer
+ * (camel-servlet, camel-jetty etc.) will by default cache the input stream
to support reading it
+ * multiple times to ensure it Camel can retrieve all data from the stream.
However you can set this
+ * option to true when you for example need to access the raw stream, such
as streaming it directly
+ * to a file or other persistent store. DefaultHttpBinding will copy the
request input stream into a
+ * stream cache and put it into message body if this option is false to
support reading the stream
+ * multiple times. If you use Servlet to bridge/proxy an endpoint then
consider enabling this option
+ * to improve performance, in case you do not need to read the message
payload multiple times. The
+ * producer (camel-http) will by default cache the response body stream. If
setting this option to
+ * true, then the producers will not cache the response body stream but use
the response stream as-is
+ * (the stream can only be read once) as the message body.
*/
public fun disableStreamCache(disableStreamCache: String) {
it.property("disableStreamCache", disableStreamCache)
}
/**
- * Determines whether or not the raw input stream from Servlet is cached or
not (Camel will read
- * the stream into a in memory/overflow to file, Stream caching) cache. By
default Camel will cache
- * the Servlet input stream to support reading it multiple times to ensure
it Camel can retrieve all
- * data from the stream. However you can set this option to true when you
for example need to access
- * the raw stream, such as streaming it directly to a file or other
persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream cache
and put it into message
- * body if this option is false to support reading the stream multiple
times. If you use Servlet to
- * bridge/proxy an endpoint then consider enabling this option to improve
performance, in case you do
- * not need to read the message payload multiple times. The http producer
will by default cache the
- * response body stream. If setting this option to true, then the producers
will not cache the
- * response body stream but use the response stream as-is as the message
body.
+ * Determines whether or not the raw input stream is cached or not. The
Camel consumer
+ * (camel-servlet, camel-jetty etc.) will by default cache the input stream
to support reading it
+ * multiple times to ensure it Camel can retrieve all data from the stream.
However you can set this
+ * option to true when you for example need to access the raw stream, such
as streaming it directly
+ * to a file or other persistent store. DefaultHttpBinding will copy the
request input stream into a
+ * stream cache and put it into message body if this option is false to
support reading the stream
+ * multiple times. If you use Servlet to bridge/proxy an endpoint then
consider enabling this option
+ * to improve performance, in case you do not need to read the message
payload multiple times. The
+ * producer (camel-http) will by default cache the response body stream. If
setting this option to
+ * true, then the producers will not cache the response body stream but use
the response stream as-is
+ * (the stream can only be read once) as the message body.
*/
public fun disableStreamCache(disableStreamCache: Boolean) {
it.property("disableStreamCache", disableStreamCache.toString())
diff --git
a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/ServletUriDsl.kt
b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/ServletUriDsl.kt
index 94822fd81dc..a2f2d3a5fe7 100644
---
a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/ServletUriDsl.kt
+++
b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/ServletUriDsl.kt
@@ -52,34 +52,34 @@ public class ServletUriDsl(
}
/**
- * Determines whether or not the raw input stream from Servlet is cached or
not (Camel will read
- * the stream into a in memory/overflow to file, Stream caching) cache. By
default Camel will cache
- * the Servlet input stream to support reading it multiple times to ensure
it Camel can retrieve all
- * data from the stream. However you can set this option to true when you
for example need to access
- * the raw stream, such as streaming it directly to a file or other
persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream cache
and put it into message
- * body if this option is false to support reading the stream multiple
times. If you use Servlet to
- * bridge/proxy an endpoint then consider enabling this option to improve
performance, in case you do
- * not need to read the message payload multiple times. The http producer
will by default cache the
- * response body stream. If setting this option to true, then the producers
will not cache the
- * response body stream but use the response stream as-is as the message
body.
+ * Determines whether or not the raw input stream is cached or not. The
Camel consumer
+ * (camel-servlet, camel-jetty etc.) will by default cache the input stream
to support reading it
+ * multiple times to ensure it Camel can retrieve all data from the stream.
However you can set this
+ * option to true when you for example need to access the raw stream, such
as streaming it directly
+ * to a file or other persistent store. DefaultHttpBinding will copy the
request input stream into a
+ * stream cache and put it into message body if this option is false to
support reading the stream
+ * multiple times. If you use Servlet to bridge/proxy an endpoint then
consider enabling this option
+ * to improve performance, in case you do not need to read the message
payload multiple times. The
+ * producer (camel-http) will by default cache the response body stream. If
setting this option to
+ * true, then the producers will not cache the response body stream but use
the response stream as-is
+ * (the stream can only be read once) as the message body.
*/
public fun disableStreamCache(disableStreamCache: String) {
it.property("disableStreamCache", disableStreamCache)
}
/**
- * Determines whether or not the raw input stream from Servlet is cached or
not (Camel will read
- * the stream into a in memory/overflow to file, Stream caching) cache. By
default Camel will cache
- * the Servlet input stream to support reading it multiple times to ensure
it Camel can retrieve all
- * data from the stream. However you can set this option to true when you
for example need to access
- * the raw stream, such as streaming it directly to a file or other
persistent store.
- * DefaultHttpBinding will copy the request input stream into a stream cache
and put it into message
- * body if this option is false to support reading the stream multiple
times. If you use Servlet to
- * bridge/proxy an endpoint then consider enabling this option to improve
performance, in case you do
- * not need to read the message payload multiple times. The http producer
will by default cache the
- * response body stream. If setting this option to true, then the producers
will not cache the
- * response body stream but use the response stream as-is as the message
body.
+ * Determines whether or not the raw input stream is cached or not. The
Camel consumer
+ * (camel-servlet, camel-jetty etc.) will by default cache the input stream
to support reading it
+ * multiple times to ensure it Camel can retrieve all data from the stream.
However you can set this
+ * option to true when you for example need to access the raw stream, such
as streaming it directly
+ * to a file or other persistent store. DefaultHttpBinding will copy the
request input stream into a
+ * stream cache and put it into message body if this option is false to
support reading the stream
+ * multiple times. If you use Servlet to bridge/proxy an endpoint then
consider enabling this option
+ * to improve performance, in case you do not need to read the message
payload multiple times. The
+ * producer (camel-http) will by default cache the response body stream. If
setting this option to
+ * true, then the producers will not cache the response body stream but use
the response stream as-is
+ * (the stream can only be read once) as the message body.
*/
public fun disableStreamCache(disableStreamCache: Boolean) {
it.property("disableStreamCache", disableStreamCache.toString())
