ratpack.http.client.ReceivedResponse Java Examples

@Override
public Promise<ReceivedResponse> request(URI uri, Action<? super RequestSpec> action) {
    // save off the current span as the parent of a future client span
    TraceContext parent = currentTraceContext.get();
    // this reference is used to manually propagate the span from the request to the response
    // we use this because we cannot assume a thread context exists betweeen them.
    AtomicReference<Span> currentSpan = new AtomicReference<>();
    return delegate.request(uri, (RequestSpec requestSpec) -> {
        try {
            action.execute(new WrappedRequestSpec(requestSpec, parent, currentSpan));
        } finally {
            // moves the span from thread local context to an atomic ref the response can read
            currentSpan.set(threadLocalSpan.remove());
        }
    }).wiretap(response -> responseWithSpan(response, currentSpan.getAndSet(null)));
}
 

private void responseWithSpan(Result<ReceivedResponse> response, Span currentSpan) {
    if (currentSpan == null) return;

    Integer statusCode = (response.isError() || response.getValue() == null)
        ? null : response.getValue().getStatusCode();

    handler.handleReceive(statusCode, response.getThrowable(), currentSpan);
}
 

@Override
public RequestSpec onRedirect(Function<? super ReceivedResponse, Action<? super RequestSpec>> function) {

    Function<? super ReceivedResponse, Action<? super RequestSpec>> wrapped =
        (ReceivedResponse response) -> redirectHandler(response).append(function.apply(response));

    this.delegate.onRedirect(wrapped);
    return this;
}
 

@Override
public void handle(Context ctx) throws Exception {
    HttpClient client = ctx.get(HttpClient.class);
    URI uri = URI.create("http://localhost:5050/employee/1");
    Promise<ReceivedResponse> responsePromise = client.get(uri);
    responsePromise.map(response -> response.getBody()
        .getText()
        .toUpperCase())
        .then(responseText -> ctx.getResponse()
            .send(responseText));
}
 

public static void main(final String[] args) throws Exception {
  final RatpackServer server = RatpackServer.start(new Action<RatpackServerSpec>() {
    @Override
    public void execute(final RatpackServerSpec ratpackServerSpec) {
      ratpackServerSpec.handlers(new Action<Chain>() {
        @Override
        public void execute(final Chain chain) {
          chain.get(new Handler() {
            @Override
            public void handle(final Context context) {
              TestUtil.checkActiveSpan();
              context.render("Test");
            }
          });
        }
      });
    }
  });

  final HttpClient client = HttpClient.of(new Action<HttpClientSpec>() {
    @Override
    public void execute(final HttpClientSpec httpClientSpec) {
      httpClientSpec
        .poolSize(10)
        .maxContentLength(ServerConfig.DEFAULT_MAX_CONTENT_LENGTH)
        .readTimeout(Duration.of(60, ChronoUnit.SECONDS))
        .byteBufAllocator(PooledByteBufAllocator.DEFAULT);
    }
  });

  try (final ExecHarness harness = ExecHarness.harness()) {
    final ExecResult<ReceivedResponse> result = harness.yield(new Function<Execution,Promise<ReceivedResponse>>() {
      @Override
      public Promise<ReceivedResponse> apply(final Execution execution) {
        return client.get(URI.create("http://localhost:5050"));
      }
    });

    final int statusCode = result.getValue().getStatusCode();
    if (200 != statusCode)
      throw new AssertionError("ERROR: response: " + statusCode);
  }

  server.stop();
  TestUtil.checkSpan(new ComponentSpanCount("netty", 2, true));
}
 

@Override
public Promise<ReceivedResponse> get(final URI uri, final Action<? super RequestSpec> requestConfigurer) {
    return request(uri, requestConfigurer.prepend(RequestSpec::get));
}
 

@Override
public Promise<ReceivedResponse> post(final URI uri, final Action<? super RequestSpec> requestConfigurer) {
    return request(uri, requestConfigurer.prepend(RequestSpec::post));
}
 

/**
 * Default redirect handler that ensures the span is marked as received before
 * a new span is created.
 */
private Action<? super RequestSpec> redirectHandler(ReceivedResponse response) {
    Span span = currentSpan.getAndSet(null);
    handler.handleReceive(response.getStatusCode(), null, span);
    return (s) -> new WrappedRequestSpec(s, parent, currentSpan);
}