Expand discussion of the `close` function for clojure clients and
the `close` method for Java clients. Add examples for making
requests with various types of clients. Fix wording/typos.
This commit restores several of the `rediret-test-async` tests, using a
client to make the requests since the client-less single-request async
APIs are no longer available.
This commit restores the `query-params-test-async` tests, using a client
to make the requests since the client-less single-request async APIs are
no longer available.
This commit removes the `request-with-reified-client` function in
async.clj in lieu of having clients just call the `request-with-client`
function.
This commit also restores documentation for the client and request
options to the `create-client` and `request-with-client` functions,
respectively. The documentation includes some updates for newer options
which are supported but not were not included in the code currently on
the master branch.
This commit removes some repeated code from the Clojure sync request
function and changes the surrounding try/catch/finally block to make use
of the Clojure `with-open` macro.
For both the Clojure and Java single request APIs, the internal
implementation now creates an http client, makes a request on it, and
calls close on the client when done. The close at the end avoids
resource leaks.
In support of this, the `JavaClient` class now requires the caller to
create an instance rather than just make a call to the static
`request` method on the `JavaClient` class.
The `coerceBodyType` method on the `JavaClient` class now closes the
body `InputStream` after coercing the stream content into a `String`.
This eliminates a possible resource leak and makes the Java-layer
coerce implementation consistent with the Clojure-layer coerce in
that the latter was already, via the use of the Clojure `slurp`
function, closing the stream content after coercing to `String`.
This commit removes the `AsyncClose` class and references to it. These
changes are in preparation for making the close call after the response
has been dereferenced - to be done in a later commit. The `persistent`
flag/option was also removed from request handling as it will no longer
be used for determining whether or not the client should be closed
following a request.
Remove the accessor for the method option in SimpleRequestOptions
and RequestOptions, as it would always be overridden by whichever
Java request method was called by the user.
Remove the client option from SimpleRequestOptions and
RequestOptions as it was not being used. Correct initialization
of the Logger in various classes to use the correct class.
Add a PersistentSyncHttpClient class, which is a wrapper around
CloseableHttpAsyncClient and allows multiple requests to be made
with a persistent synchronous client.
Separate the Java RequestOptions class into two new classes:
RequestOptions, which contains options related to the request,
and ClientOptions, which contains options related to the client.
Both are now required when calling the request methods in
AsyncHttpClient and SyncHttpClient.
The test code related to the configurable SSL protocols was
written using some ciphers that are available in OpenJDK, but
are not available by default in Oracle JDK. This caused the
tests to fail on Oracle JDKs.
This commit changes the test to use some older ciphers that
are available in the Oracle JDK out of the box.
This commit moves each close call made on a `CloseableHttpAsyncClient`
from the thread on which the request callback is made over to a
different thread in order to avoid a deadlock.
Previously, the client close call was made in the context of thread from
which the callback was invoked. The Apache HTTP async client library
makes these calls from one of its i/o reactor threads. In the case of a
"failed" request, e.g., failure to make the client connection, this call
occurs in the context of the primary i/o reactor thread. The client
close call does an indefinite join on the primary i/o reactor thread
and, therefore, this call causes a deadlock. The client never closes
and all resources associated with it - threads, file descriptors, etc. -
remain open until the process is shutdown.
This commit introduces a new class, `AsyncClose`, which manages a small,
fixed size thread pool from which client close calls can be executed.
The `async` Clojure and `JavaClient` APIs were updated to use `AsyncClose`
whenever a client needs to be closed from a callback.
This commit adds configuration settings for the SSL protocols
and cipher suites, in both the java and clojure clients. It
also adds a list of default protocols which will be used if
the protocols setting is not explicitly set.
Prior to this commit, we were using `HttpAsyncClientBuilder.setSSLContext`
to set up our HTTPS SSL configuration. That method doesn't provide
a mechanism for specifying a list of acceptable protocols or ciphers.
This commit simply ports the code over to use `.setSSLStrategy`
instead, because it allows a larger number of configuration options.
