@Override protected void applyStatusCode() { Integer statusCode = getStatusCodeValue(); if (statusCode != null) { this.response.status(statusCode); } }
@Override protected Mono<Void> writeWithInternal(Publisher<? extends DataBuffer> publisher) { return this.response.send(toByteBufs(publisher)).then(); }
public ReactorServerHttpResponse(HttpServerResponse response, DataBufferFactory bufferFactory) { super(bufferFactory, new HttpHeaders(new NettyHeadersAdapter(response.responseHeaders()))); Assert.notNull(response, "HttpServerResponse must not be null"); this.response = response; }
@Override public Mono<Void> apply(HttpServerRequest reactorRequest, HttpServerResponse reactorResponse) { NettyDataBufferFactory bufferFactory = new NettyDataBufferFactory(reactorResponse.alloc()); try { ReactorServerHttpRequest request = new ReactorServerHttpRequest(reactorRequest, bufferFactory); ServerHttpResponse response = new ReactorServerHttpResponse(reactorResponse, bufferFactory); if (request.getMethod() == HttpMethod.HEAD) { response = new HttpHeadResponseDecorator(response); } return this.httpHandler.handle(request, response) .doOnError(ex -> logger.trace(request.getLogPrefix() + "Failed to complete: " + ex.getMessage())) .doOnSuccess(aVoid -> logger.trace(request.getLogPrefix() + "Handling completed")); } catch (URISyntaxException ex) { if (logger.isDebugEnabled()) { logger.debug("Failed to get request URI: " + ex.getMessage()); } reactorResponse.status(HttpResponseStatus.BAD_REQUEST); return Mono.empty(); } }
@Override public Mono<Void> upgrade(ServerWebExchange exchange, WebSocketHandler handler, @Nullable String subProtocol, Supplier<HandshakeInfo> handshakeInfoFactory) { ServerHttpResponse response = exchange.getResponse(); HttpServerResponse reactorResponse = ((AbstractServerHttpResponse) response).getNativeResponse(); HandshakeInfo handshakeInfo = handshakeInfoFactory.get(); NettyDataBufferFactory bufferFactory = (NettyDataBufferFactory) response.bufferFactory(); return reactorResponse.sendWebsocket(subProtocol, this.maxFramePayloadLength, (in, out) -> { ReactorNettyWebSocketSession session = new ReactorNettyWebSocketSession( in, out, handshakeInfo, bufferFactory, this.maxFramePayloadLength); return handler.handle(session); }); }
HttpServer.create() .host("localhost") .route(r -> r.get("/201", (req, res) -> res.addHeader ("Content-Length", "0") .status(HttpResponseStatus.CREATED) .sendHeaders()) .get("/204", (req, res) -> res.status (HttpResponseStatus.NO_CONTENT) .sendHeaders()) .get("/200", (req, res) -> res.addHeader("Content-Length", "0") .sendHeaders())) .bindNow();
.wiretap(true) .route(r -> r.get("/1", (req, res) -> res.sendRedirect("http://localhost:" + serverPort1 + "/3")) .get("/2", (req, res) -> res.status(301) .header(HttpHeaderNames.LOCATION, "http://localhost:" + serverPort1 + "/3") .send()) .get("/3", (req, res) -> res.status(200) .sendString(Mono.just("OK")))) .wiretap(true) .bindNow();
@Test public void sendZipFileCompressionPredicate_3() throws IOException { Path path = Files.createTempFile(null, ".zip"); Files.copy(this.getClass().getResourceAsStream("/zipFile.zip"), path, StandardCopyOption.REPLACE_EXISTING); path.toFile().deleteOnExit(); try (FileSystem zipFs = FileSystems.newFileSystem(path, null)) { Path fromZipFile = zipFs.getPath("/largeFile.txt"); long fileSize = Files.size(fromZipFile); assertSendFile(out -> out.addHeader("test", "test").sendFile(fromZipFile, 0, fileSize), true, -1, (req, res) -> !res.responseHeaders().contains("test")); } }
private Mono<Void> ok(HttpServerResponse httpResponse, ServiceMessage response) { ByteBuf content = response.hasData(ByteBuf.class) ? response.data() : encodeData(response.data(), response.dataFormatOrDefault()); return httpResponse.status(OK).sendObject(content).then(); }
private Mono<Void> handle(HttpServerRequest req, HttpServerResponse res) { res.status(HttpResponseStatus.OK); res.addHeader("Content-Type", TextFormat.CONTENT_TYPE_004); return res.sendString(Mono.just(registry.scrape())).then(); }
.host("localhost") .route(r -> r.route(req -> req.uri().startsWith("/1"), (req, res) -> res.sendString(Mono.just("OK"))) .route(req -> req.uri().startsWith("/2"), (req, res) -> res.chunkedTransfer(false) .sendString(Mono.just("OK"))) .route(req -> req.uri().startsWith("/3"), (req, res) -> { res.responseHeaders().set("Content-Length", 2); return res.sendString(Mono.just("OK")); }) .route(req -> req.uri().startsWith("/4"), (req, res) -> res.sendHeaders()) .route(req -> req.uri().startsWith("/5"), (req, res) -> res.chunkedTransfer(false) .sendHeaders()) .route(req -> req.uri().startsWith("/6"), (req, res) -> { res.responseHeaders().set("Content-Length", 2); return res.sendHeaders(); }) .route(req -> req.uri().startsWith("/7"), (req, res) -> res.send()) .route(req -> req.uri().startsWith("/8"), (req, res) -> res.chunkedTransfer(false) .send()) .route(req -> req.uri().startsWith("/9"), (req, res) -> { res.responseHeaders().set("Content-Length", 2);
@Test public void sendZipFileCompressionSize_1() throws IOException { Path path = Files.createTempFile(null, ".zip"); Files.copy(this.getClass().getResourceAsStream("/zipFile.zip"), path, StandardCopyOption.REPLACE_EXISTING); path.toFile().deleteOnExit(); try (FileSystem zipFs = FileSystems.newFileSystem(path, null)) { Path fromZipFile = zipFs.getPath("/largeFile.txt"); long fileSize = Files.size(fromZipFile); assertSendFile(out -> out.addHeader(HttpHeaderNames.CONTENT_LENGTH, "1245") .sendFile(fromZipFile, 0, fileSize), true, 2048, null); } }
.port(port) .handle((request, response) -> { response.chunkedTransfer(false); return response.addHeader("Content-type", "text/plain") .addHeader("Expires", "0") .addHeader("X-GPFDIST-VERSION", "Spring XD") .addHeader("X-GP-PROTO", "1") .addHeader("Cache-Control", "no-cache") .addHeader("Connection", "close") .options(NettyPipeline.SendOptions::flushOnEach) .send(bufferStream.doOnNext(d -> integer.getAndIncrement()) .take(takeCount) .doOnNext(d -> integerPostTake.getAndIncrement()) new GpdistCodec( response .alloc()))); }) .wiretap(true)
@Override public Mono<Void> writeWith(Path file, long position, long count) { return doCommit(() -> this.response.sendFile(file, position, count).then()); }
private void setupFakeProtocolListener() { broadcaster = TopicProcessor.create(); final Processor<List<String>, List<String>> processor = WorkQueueProcessor.<List<String>>builder().autoCancel(false).build(); Flux.from(broadcaster) .buffer(5) .subscribe(processor); httpServer = HttpServer.create() .port(0) .route(r -> r.get("/data", (req, resp) -> resp.options(NettyPipeline.SendOptions::flushOnEach) .send(Flux.from(processor) .log("server") .timeout(Duration.ofSeconds( 2), Flux.empty()) .concatWith(Flux.just( new ArrayList<>())) .map(new DummyListEncoder( resp.alloc() ))))) .wiretap(true) .bindNow(); }
@Override public HttpServerRoutes directory(String uri, Path directory, Function<HttpServerResponse, HttpServerResponse> interceptor) { Objects.requireNonNull(directory, "directory"); return route(HttpPredicate.prefix(uri), (req, resp) -> { String prefix = URI.create(req.uri()) .getPath() .replaceFirst(uri, ""); if(prefix.charAt(0) == '/'){ prefix = prefix.substring(1); } Path p = directory.resolve(prefix); if (Files.isReadable(p)) { if (interceptor != null) { return interceptor.apply(resp) .sendFile(p); } return resp.sendFile(p); } return resp.sendNotFound(); }); }