ratpack.handling.Context Java Examples

@Override
public void handle(Context context) throws Exception {
    context.parse(Map.class)
        .then(payload -> {
            Map<String, Object> parameters = (Map<String, Object>) payload.get("parameters");
            ExecutionResult executionResult = graphql.execute(payload.get(SchemaUtils.QUERY)
                .toString(), null, this, parameters);
            Map<String, Object> result = new LinkedHashMap<>();
            if (executionResult.getErrors()
                .isEmpty()) {
                result.put(SchemaUtils.DATA, executionResult.getData());
            } else {
                result.put(SchemaUtils.ERRORS, executionResult.getErrors());
                LOGGER.warning("Errors: " + executionResult.getErrors());
            }
            context.render(json(result));
        });
}
 

@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));
}
 

@Override
public void handle(Context ctx) throws Exception {
  ServerRequest request = new ServerRequestImpl(ctx.getRequest());
  final Span span = handler.handleReceive(extractor, request);

  ctx.getResponse().beforeSend(response -> {
    ServerResponse serverResponse = new ServerResponseImpl(response, request, ctx.getPathBinding());
    handler.handleSend(serverResponse, null, span);
  });
  //place the Span in scope so that downstream code (e.g. Ratpack handlers
  //further on in the chain) can see the Span.
  try (Tracer.SpanInScope scope = tracing.tracer().withSpanInScope(span)) {
    ctx.next();
  }
}
 

@Override
public String getUrl() {
  PublicAddress publicAddress = request.get(Context.class).get(PublicAddress.class);
  return publicAddress.builder()
                      .path(request.getPath())
                      .params(request.getQueryParams())
                      .build().toString();
}
 

@Override
public void handle(Context ctx) throws Exception {
    EmployeeRepository repository = ctx.get(EmployeeRepository.class);
    Long id = Long.valueOf(ctx.getPathTokens()
        .get("id"));
    Promise<Employee> employeePromise = repository.findEmployeeById(id);
    employeePromise.map(employee -> employee.getName())
        .then(name -> ctx.getResponse()
            .send(name));
}
 

@Override
public void handle(Context ctx)  {
    ctx.parse(fromJson(JsonRpcRequest.class)).then(rpcReq -> {
        if (allowedMethods.contains(rpcReq.getMethod())) {
            rpcClient.call(rpcReq).then(rpcResponse -> ctx.render(json(rpcResponse)));
        } else {
            // Should we send a JsonRpcResponse here?
            ctx.getResponse().status(403).send("JSON-RPC method not allowed by proxy");
        }
    });
}
 

@Override
public void handle(Context ctx) throws Exception {
    boolean permission = rateLimiter.acquirePermission();
    if (Thread.interrupted()) {
        throw new IllegalStateException("Thread was interrupted during permission wait");
    }
    if (!permission) {
        Throwable t = createRequestNotPermitted(rateLimiter);
        ctx.error(t);
    } else {
        ctx.next();
    }
}
 

protected int parseQueryCount(Context ctx) {
    String textValue = ctx.getRequest().getQueryParams().get("queries");

    if (textValue == null) {
        return 1;
    }
    int parsedValue;
    try {
        parsedValue = Integer.parseInt(textValue);
    } catch (NumberFormatException e) {
        return 1;
    }
    return Math.min(500, Math.max(1, parsedValue));
}
 

@Override
public void handle(Context ctx) {
    MutableHeaders headers = ctx.getResponse().getHeaders();
    headers.set(HttpHeaderNames.DATE, dateHelper.getDate());
    headers.set(SERVER, RATPACK);
    ctx.next();
}
 

public void handle(Context ctx, DbRepository repository) {
    repository.fortunes().then(fortunes -> {
        fortunes.add(new Fortune(0, "Additional fortune added at request time."));
        fortunes.sort(Comparator.comparing(fortune -> fortune.message));
        ctx.render(Template.handlebarsTemplate("fortunes", Collections.singletonMap("fortunes", fortunes), "text/html; charset=UTF-8"));
    });
}
 

@Override
public void handle(Context ctx) throws Exception {
	MutableHeaders headers = ctx.getResponse().getHeaders();
    headers.set("Access-Control-Allow-Origin", "*");
	ctx.next();
}
 

void renderName(Context ctx) {
  var name = ctx.getPathTokens().get("name");
  System.out.println(String.format("Hello %s", name));
  ctx.render(String.format("[renderName] Hello <%s>!\n", name));
}
 

@Override
public void handle(Context ctx) throws Exception {
    ctx.getResponse()
        .send("Hello Foo!");
}
 

@Override
public void handle(Context ctx) {
    ctx.getResponse().send(MESSAGE);
}
 

@Override
public void handle(Context ctx) {
    ctx.render(json(Collections.singletonMap(MESSAGE, HELLO)));
}
 

public void handle(Context ctx, DbRepository repository) {
    int queries = parseQueryCount(ctx);

    repository.getWorlds(getNumbers(queries)).then(result -> ctx.render(json(result)));
}
 

public void handle(Context ctx, DbRepository repository) {
    int queries = parseQueryCount(ctx);

    repository.findAndUpdateWorlds(getNumbers(queries), getNumbers(queries)).then(result -> ctx.render(json(result)));
}
 

public void handle(Context ctx, DbRepository repository) {
    repository.getWorld(randomWorldNumber()).then(result -> ctx.render(json(result)));
}
 

@Override
public void handle(Context ctx) {
    JsonRpcRequest rpcReq = new JsonRpcRequest("getblockchaininfo");
    rpcClient.call(rpcReq).then(rpcResponse -> ctx.render(json(rpcResponse)));
}
 

@Override
public void handle(Context ctx) {
    JsonRpcRequest rpcReq = new JsonRpcRequest("setgenerate", Arrays.asList(true, 1));
    rpcClient.call(rpcReq).then(rpcResponse -> ctx.render(json(rpcResponse)));
}
 

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));
}
 

void renderWorld(Context ctx) {
  var message = "Hello World!";
  System.out.println(message);
  ctx.render(String.format("[renderWorld] %s\n", message));
}