How to use

HttpServerResponse

in

reactor.netty.http.server

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

private Publisher<Void> methodNotAllowed(HttpServerResponse httpResponse) {
 return httpResponse.addHeader(ALLOW, POST.name()).status(METHOD_NOT_ALLOWED).send();
}

@Override
public Mono<Void> sendRedirect(String location) {
  Objects.requireNonNull(location, "location");
  return this.status(HttpResponseStatus.FOUND)
        .header(HttpHeaderNames.LOCATION, location)
        .send();
}

@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> noContent(HttpServerResponse httpResponse) {
 return httpResponse.status(NO_CONTENT).send();
}

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)

@Test
public void sendFileAsync4096Negative() throws IOException, URISyntaxException {
  doTestSendFileAsync((req, resp) -> req.receive()
                     .take(10)
                     .doOnNext(b -> resp.status(500)
                               .header(HttpHeaderNames.CONNECTION, "close"))
                     .then(),
      4096, "error".getBytes(Charset.defaultCharset()));
}

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