public static void main(String... args) throws Exception {
final AdminBuilder adminBuilder = AdminBuilder.adminBuilder();
final ServiceEndpointServer adminServer = adminBuilder.build();
adminServer.startServer();
final HealthServiceAsync healthService = adminBuilder.getHealthService();
healthService.register("foo", 1, TimeUnit.DAYS);
healthService.checkInOk("foo");
healthService.register("bar", 1, TimeUnit.DAYS);
healthService.checkInOk("bar");
healthService.clientProxyFlush();
Sys.sleep(100);
final HttpClient client =
HttpClientBuilder.httpClientBuilder().setPort(adminBuilder.getPort()).buildAndStart();
final HttpResponse httpResponse = client.get("/services/qbit-admin/ok");
puts(httpResponse.body());
final HttpResponse httpResponsePage = client.get("/qbit/admin.html");
puts(httpResponsePage.body());
}
@Test
public void test() throws Exception {
final int openPortStartAt = PortUtils.findOpenPortStartAt(7777);
HttpServer server = HttpServerBuilder.httpServerBuilder().setPort(openPortStartAt).build();
server.setHttpRequestConsumer(
serverRequest -> {
final MultiMap<String, String> headers = MultiMap.multiMap();
headers.add("foo", "bar").add("foo", "baz");
serverRequest.getReceiver().response(200, "application/json", "true", headers);
});
server.startServer();
HttpClient client =
HttpClientBuilder.httpClientBuilder().setPort(openPortStartAt).setHost("localhost").build();
client.start();
final HttpTextResponse httpResponse = client.get("/hi");
Sys.sleep(1000);
puts(httpResponse.headers());
boolean foundFoo = httpResponse.headers().keySet().contains("foo");
assertTrue(foundFoo);
}
/**
* Checks client health periodically to see if we are connected. Tries to reconnect if not
* connected.
*/
private void checkClient() {
try {
/** If the errorCount is greater than 0, make sure we are still connected. */
if (errorCount.get() > 0) {
errorCount.set(0);
if (backendServiceHttpClient == null || backendServiceHttpClient.isClosed()) {
if (backendServiceHttpClient != null) {
try {
backendServiceHttpClient.stop();
} catch (Exception ex) {
logger.debug("Was unable to stop the client connection", ex);
}
}
backendServiceHttpClient = httpClientBuilder.buildAndStart();
lastHttpClientStart = time;
}
}
/** If the ping builder is present, use it to ping the service. */
if (pingBuilder.isPresent()) {
if (backendServiceHttpClient != null) {
pingBuilder
.get()
.setBinaryReceiver(
(code, contentType, body) -> {
if (code >= 200 && code < 299) {
pingCount.incrementAndGet();
} else {
errorCount.incrementAndGet();
}
})
.setErrorHandler(
e -> {
logger.error("Error doing ping operation", e);
errorCount.incrementAndGet();
});
final HttpRequest httpRequest = pingBuilder.get().build();
backendServiceHttpClient.sendHttpRequest(httpRequest);
}
}
} catch (Exception ex) {
errorHandler.accept(ex);
logger.error("Unable to check connection");
}
}
/**
* Creates a backend request from the client request and then forwards it.
*
* @param clientRequest clientRequest
*/
private void createBackEndRequestPopulateAndForward(final HttpRequest clientRequest) {
try {
if (backendServiceHttpClient == null) {
handleHttpClientErrorsForBackend(
clientRequest, new HttpClientClosedConnectionException("Not connected"));
long timeSinceLastStart = time - lastHttpClientStart;
if (timeSinceLastStart > 10_000) {
checkClient();
}
return;
}
/* forward request to backend client. */
final HttpRequestBuilder httpRequestBuilder =
HttpRequestBuilder.httpRequestBuilder()
.copyRequest(clientRequest)
.setBinaryReceiver(
new HttpBinaryReceiver() {
@Override
public void response(
final int code,
final String contentType,
final byte[] body,
final MultiMap<String, String> headers) {
handleBackendClientResponses(clientRequest, code, contentType, body, headers);
}
@Override
public void response(int code, String contentType, byte[] body) {
response(code, contentType, body, MultiMap.empty());
}
})
.setErrorHandler(e -> handleHttpClientErrorsForBackend(clientRequest, e));
/** Give user of the lib a chance to populate headers and such. */
beforeSend.accept(httpRequestBuilder);
backendServiceHttpClient.sendHttpRequest(httpRequestBuilder.build());
} catch (HttpClientClosedConnectionException httpClientClosedConnectionException) {
errorCount.incrementAndGet();
errorHandler.accept(httpClientClosedConnectionException);
logger.error("Unable to forward request", httpClientClosedConnectionException);
handleHttpClientErrorsForBackend(clientRequest, httpClientClosedConnectionException);
backendServiceHttpClient = null;
long timeSinceLastStart = time - lastHttpClientStart;
if (timeSinceLastStart > 10_000) {
checkClient();
}
} catch (Exception ex) {
errorCount.incrementAndGet();
errorHandler.accept(ex);
logger.error("Unable to forward request", ex);
handleHttpClientErrorsForBackend(clientRequest, ex);
long timeSinceLastStart = time - lastHttpClientStart;
if (timeSinceLastStart > 10_000) {
checkClient();
}
}
}