@Override public void forwardTo(Response response) { response.getHeaders().copy(headers); response.status(status); ByteBuf buffer = typedData.getBuffer(); if (buffer.readableBytes() > 0) { response.send(buffer.retain()); } else { buffer.release(); response.send(); } }
protected void sendResponseData(Context ctx, ResponseData r) { ctx.getResponse() .status(r.status) .contentType(r.contentType) .send(r.text); }
@SuppressWarnings("ThrowableResultOfMethodCallIgnored") @Override public void render(Context ctx, HealthCheckResults healthCheckResults) throws Exception { ByteBuf buffer = byteBufAllocator.buffer(); try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new ByteBufOutputStream(buffer)))) { healthCheckResults.writeTo(writer); } catch (Exception e) { buffer.release(); throw e; } ctx.getResponse() .contentTypeIfNotSet(HttpHeaderConstants.PLAIN_TEXT_UTF8) .status(healthCheckResults.isUnhealthy() ? 503 : 200) .send(buffer); } }
@Override public void render(Context ctx, CharSequence charSequence) { ctx.getResponse().send(charSequence.toString()); }
public static void sendFile(Context context, Path file, BasicFileAttributes attributes) { Date date = new Date(attributes.lastModifiedTime().toMillis()); context.lastModified(date, () -> { final String ifNoneMatch = context.getRequest().getHeaders().get(HttpHeaderNames.IF_NONE_MATCH); Response response = context.getResponse(); if (ifNoneMatch != null && ifNoneMatch.trim().equals("*")) { response.status(NOT_MODIFIED.code()).send(); return; } response.contentTypeIfNotSet(() -> context.get(MimeTypes.class).getContentType(file.getFileName().toString())); response.getHeaders().set(HttpHeaderConstants.CONTENT_LENGTH, Long.toString(attributes.size())); try { response.sendFile(file); } catch (Exception e) { throw Exceptions.uncheck(e); } }); }
@Override public void render(Context context) throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); OutputStreamWriter writer = new OutputStreamWriter(out, CharsetUtil.encoder(getEncoding())); MarkupBuilder markupBuilder = new MarkupBuilder(writer); ClosureUtil.configureDelegateFirst(markupBuilder, markupBuilder, getDefinition()); context.getResponse().contentType(getContentType()).send(out.toByteArray()); } }
@Override public void setResponseStatus(int code) { response.status(code); }
@Override public void render(Context context, JsonRender object) throws Exception { ObjectWriter writer = object.getObjectWriter(); if (writer == null) { writer = defaultObjectWriter; } ByteBuf buffer = context.get(ByteBufAllocator.class).buffer(); OutputStream outputStream = new ByteBufOutputStream(buffer); try { writer.writeValue(outputStream, object.getObject()); } catch (JsonProcessingException e) { buffer.release(); context.error(e); return; } context.getResponse() .contentTypeIfNotSet(HttpHeaderConstants.JSON) .send(buffer); }
@Override public void forwardTo(Response response, Action<? super MutableHeaders> headerMutator) { MutableHeaders outgoingHeaders = response.getHeaders(); outgoingHeaders.copy(headers); outgoingHeaders.remove(HttpHeaderNames.CONNECTION); Exceptions.uncheck(() -> headerMutator.execute(outgoingHeaders)); response.status(status);
@Override public void setResponseContentType(String content) { response.contentType(content); }
LOGGER.warn(message); response.getHeaders().clear(); CharBuffer charBuffer = CharBuffer.wrap(message); body = ByteBufUtil.encodeString(ctx.alloc(), charBuffer, CharsetUtil.UTF_8); response.contentType(HttpHeaderConstants.PLAIN_TEXT_UTF8); } else { body = Unpooled.EMPTY_BUFFER; response.getHeaders().set(HttpHeaderConstants.CONTENT_LENGTH, body.readableBytes()); responseTransmitter.transmit(HttpResponseStatus.INTERNAL_SERVER_ERROR, body);
/** * {@inheritDoc} */ @Override public void render(Context context) throws Exception { ByteBufAllocator bufferAllocator = context.get(ByteBufAllocator.class); Response response = context.getResponse(); response.getHeaders().add(HttpHeaderConstants.CONTENT_TYPE, HttpHeaderConstants.TEXT_EVENT_STREAM_CHARSET_UTF_8); response.getHeaders().add(HttpHeaderConstants.TRANSFER_ENCODING, HttpHeaderConstants.CHUNKED); response.getHeaders().add(HttpHeaderConstants.CACHE_CONTROL, HttpHeaderConstants.NO_CACHE_FULL); response.getHeaders().add(HttpHeaderConstants.PRAGMA, HttpHeaderConstants.NO_CACHE); response.sendStream(Streams.map(publisher, i -> ServerSentEventEncoder.INSTANCE.encode(i, bufferAllocator))); }
throw uncheck(e); // what to do here? } finally { status = response.getStatus(); cookies = Collections.unmodifiableSet(response.getCookies());
@Override public void setResponseHeader(String name, String value) { response.getHeaders().set(name, value); }
/** * Adds the number of milliseconds of elapsed time between {@link Request#getTimestamp()} and when the response is ready to be sent. * <p> * The timer is stopped, and the header added, by {@link Response#beforeSend(ratpack.func.Action)}. * This means that the time value is the elapsed time, commonly referred to as wall clock time, and not CPU time. * Similarly, it does not include the time to actually start sending data out over the socket. * It effectively times the application processing. * <p> * The value is in milliseconds, accurate to 5 decimal places. * * @param ctx the handling context. */ @Override public void handle(Context ctx) { Response response = ctx.getResponse(); response.beforeSend(m -> { Clock clock = ctx.get(Clock.class); Instant start = ctx.getRequest().getTimestamp(); long nanos = start.until(Instant.now(clock), ChronoUnit.NANOS); BigDecimal diffNanos = new BigDecimal(nanos); BigDecimal diffMillis = diffNanos.divide(NANOS_IN_MILLIS, 5, RoundingMode.UP); m.getHeaders().set(HEADER_NAME, diffMillis.toString()); }); ctx.next(); } }
/** * Sets the response {@code Content-Type} header, if it has not already been set. * * @param contentType The value of the {@code Content-Type} header * @return This */ default Response contentTypeIfNotSet(CharSequence contentType) { return contentTypeIfNotSet(() -> contentType); }
@Override public void addResponseCookie(Cookie cookie) { final DefaultCookie newCookie = new DefaultCookie(cookie.getName(), cookie.getValue()); newCookie.setDomain(cookie.getDomain()); newCookie.setPath(cookie.getPath()); if (cookie.getMaxAge() >= 0) { newCookie.setMaxAge(cookie.getMaxAge()); } newCookie.setSecure(cookie.isSecure()); newCookie.setHttpOnly(cookie.isHttpOnly()); response.getCookies().add(newCookie); }
private void onErrorHandlerError(ServerErrorHandler serverErrorHandler, Throwable original, Throwable errorHandlerThrowable) { String msg = "Throwable thrown by error handler " + serverErrorHandler + " while handling throwable\n" + "Original throwable: " + getStackTraceAsString(original) + "\n" + "Error handler throwable: " + getStackTraceAsString(errorHandlerThrowable); LOGGER.error(msg); Response response = requestConstants.response.status(500); if (getServerConfig().isDevelopment()) { response.send(msg); } else { response.send(); } }