new HttpClientRequest()
Represents a client-side HTTP request.
- Source:
Methods
connection() → {HttpConnection}
- Source:
Returns:
-
the HttpConnection associated with this request
-
- Type
- HttpConnection
connectionHandler(handler) → {HttpClientRequest}
Set a connection handler called when an HTTP connection has been established.
Parameters:
Name | Type | Description |
---|---|---|
handler |
function | the handler |
- Source:
Returns:
a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
continueHandler(handler) → {HttpClientRequest}
If you send an HTTP request with the header
Expect
set to the value 100-continue
and the server responds with an interim HTTP response with a status code of 100
and a continue handler
has been set using this method, then the handler
will be called.
You can then continue to write data to the request body and later end it. This is normally used in conjunction with the HttpClientRequest#sendHead method to force the request header to be written before the request has ended.
Parameters:
Name | Type | Description |
---|---|---|
handler |
function |
- Source:
Returns:
a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
drainHandler(handler) → {HttpClientRequest}
Parameters:
Name | Type | Description |
---|---|---|
handler |
function |
- Source:
Returns:
- Type
- HttpClientRequest
end(chunk, enc)
Same as HttpClientRequest#end but writes a String with the specified encoding
Parameters:
Name | Type | Description |
---|---|---|
chunk |
string | |
enc |
string |
- Source:
endHandler(endHandler) → {HttpClientRequest}
Parameters:
Name | Type | Description |
---|---|---|
endHandler |
function |
- Source:
Returns:
- Type
- HttpClientRequest
exceptionHandler(handler) → {HttpClientRequest}
Parameters:
Name | Type | Description |
---|---|---|
handler |
function |
- Source:
Returns:
- Type
- HttpClientRequest
getHost() → {string}
- Source:
Returns:
-
the request host. For HTTP2 it returns the pseudo header otherwise it returns the header
-
- Type
- string
getRawMethod() → {string}
- Source:
Returns:
-
the raw value of the method this request sends
-
- Type
- string
handler(handler) → {HttpClientRequest}
Parameters:
Name | Type | Description |
---|---|---|
handler |
function |
- Source:
Returns:
- Type
- HttpClientRequest
headers() → {MultiMap}
- Source:
Returns:
-
The HTTP headers
-
- Type
- MultiMap
isChunked() → {boolean}
- Source:
Returns:
-
Is the request chunked?
-
- Type
- boolean
method() → {Object}
The HTTP method for the request.
- Source:
Returns:
- Type
- Object
path() → {string}
- Source:
Returns:
-
The path part of the uri. For example /somepath/somemorepath/someresource.foo
-
- Type
- string
pause() → {HttpClientRequest}
- Source:
Returns:
- Type
- HttpClientRequest
pushHandler(handler) → {HttpClientRequest}
Set a push handler for this request.
The handler is called when the client receives a push promise from the server. The handler can be called
multiple times, for each push promise.
The handler is called with a read-only HttpClientRequest, the following methods can be called:
- HttpClientRequest#method
- HttpClientRequest#uri
- HttpClientRequest#headers
- HttpClientRequest#getHost
Parameters:
Name | Type | Description |
---|---|---|
handler |
function | the handler |
- Source:
Returns:
a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
putHeader(name, value) → {HttpClientRequest}
Put an HTTP header
Parameters:
Name | Type | Description |
---|---|---|
name |
string | The header name |
value |
string | The header value |
- Source:
Returns:
a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
query() → {string}
- Source:
Returns:
-
the query part of the uri. For example someparam=32&someotherparam=x
-
- Type
- string
reset(code)
Reset this stream with the error
code
.
Parameters:
Name | Type | Description |
---|---|---|
code |
number | the error code |
- Source:
resume() → {HttpClientRequest}
- Source:
Returns:
- Type
- HttpClientRequest
sendHead(completionHandler) → {HttpClientRequest}
Like HttpClientRequest#sendHead but with an handler after headers have been sent. The handler will be called with
the HttpVersion if it can be determined or null otherwise.
Parameters:
Name | Type | Description |
---|---|---|
completionHandler |
function |
- Source:
Returns:
- Type
- HttpClientRequest
setChunked(chunked) → {HttpClientRequest}
If chunked is true then the request will be set into HTTP chunked mode
Parameters:
Name | Type | Description |
---|---|---|
chunked |
boolean | true if chunked encoding |
- Source:
Returns:
a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
setHost(host) → {HttpClientRequest}
Set the request host.
For HTTP2 it sets the pseudo header otherwise it sets the header
Parameters:
Name | Type | Description |
---|---|---|
host |
string |
- Source:
Returns:
- Type
- HttpClientRequest
setRawMethod(method) → {HttpClientRequest}
Set the value the method to send when the method is used.
Parameters:
Name | Type | Description |
---|---|---|
method |
string | the raw method |
- Source:
Returns:
a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
setTimeout(timeoutMs) → {HttpClientRequest}
Set's the amount of time after which if the request does not return any data within the timeout period an
TimeoutException will be passed to the exception handler (if provided) and
the request will be closed.
Calling this method more than once has the effect of canceling any existing timeout and starting the timeout from scratch.
Parameters:
Name | Type | Description |
---|---|---|
timeoutMs |
number | The quantity of time in milliseconds. |
- Source:
Returns:
a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
setWriteQueueMaxSize(maxSize) → {HttpClientRequest}
Parameters:
Name | Type | Description |
---|---|---|
maxSize |
number |
- Source:
Returns:
- Type
- HttpClientRequest
streamId() → {number}
- Source:
Returns:
-
the id of the stream of this response, when it is not yet determined, i.e the request has not been yet sent or it is not supported HTTP/1.x
-
- Type
- number
uri() → {string}
- Source:
Returns:
-
The URI of the request.
-
- Type
- string
write(chunk, enc) → {HttpClientRequest}
Write a String to the request body, encoded using the encoding
enc
.
Parameters:
Name | Type | Description |
---|---|---|
chunk |
string | |
enc |
string |
- Source:
Returns:
@return a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
writeCustomFrame(type, flags, payload) → {HttpClientRequest}
Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.
The frame is sent immediatly and is not subject to flow control.
This method must be called after the request headers have been sent and only for the protocol HTTP/2. The HttpClientRequest#sendHead should be used for this purpose.
Parameters:
Name | Type | Description |
---|---|---|
type |
number | the 8-bit frame type |
flags |
number | the 8-bit frame flags |
payload |
Buffer | the frame payload |
- Source:
Returns:
a reference to this, so the API can be used fluently
- Type
- HttpClientRequest
writeQueueFull() → {boolean}
This will return
true
if there are more bytes in the write queue than the value set using HttpClientRequest#setWriteQueueMaxSize
- Source:
Returns:
true if write queue is full
- Type
- boolean