How to use

DefaultFullHttpRequest

in

io.netty.handler.codec.http

private FullHttpRequest createFullHttpRequest(HttpHeaders headers) {
  io.netty.handler.codec.http.HttpMethod nettyMethod =
      io.netty.handler.codec.http.HttpMethod.valueOf(this.method.name());
  String authority = this.uri.getRawAuthority();
  String path = this.uri.toString().substring(this.uri.toString().indexOf(authority) + authority.length());
  FullHttpRequest nettyRequest = new DefaultFullHttpRequest(
      HttpVersion.HTTP_1_1, nettyMethod, path, this.body.buffer());
  nettyRequest.headers().set(HttpHeaders.HOST, this.uri.getHost() + ":" + getPort(this.uri));
  nettyRequest.headers().set(HttpHeaders.CONNECTION, "close");
  headers.forEach((headerName, headerValues) -> nettyRequest.headers().add(headerName, headerValues));
  if (!nettyRequest.headers().contains(HttpHeaders.CONTENT_LENGTH) && this.body.buffer().readableBytes() > 0) {
    nettyRequest.headers().set(HttpHeaders.CONTENT_LENGTH, this.body.buffer().readableBytes());
  }
  return nettyRequest;
}

@Override
public FullHttpRequest replace(ByteBuf content) {
  DefaultFullHttpRequest duplicate = new DefaultFullHttpRequest(protocolVersion(), method(), uri(), content);
  duplicate.headers().set(headers());
  duplicate.trailingHeaders().set(trailingHeaders());
  return duplicate;
}

  protocol = nativeRequest.protocolVersion().text();
String path = nativeRequest.uri();
int queryIndex = path.indexOf('?');
if (queryIndex > -1) {
    context,
    protocol,
    nativeRequest.method().asciiName().toString().toLowerCase(),
    path,
    copyQueryParams(nativeRequest),
  final ByteBuf chunk = ((DefaultFullHttpRequest) nativeRequest).content();
  request.bufferBodyContents(new DefaultLastHttpContent(chunk));

@Override
public FullHttpRequest replace(ByteBuf content) {
  FullHttpRequest request = new DefaultFullHttpRequest(protocolVersion(), method(), uri(), content,
      headers().copy(), trailingHeaders().copy());
  request.setDecoderResult(decoderResult());
  return request;
}

@Override
public FullHttpRequest copy() {
  return replace(content().copy());
}

@Override
public FullHttpRequest duplicate() {
  return replace(content().duplicate());
}

public void createRequest(ByteBuf content) {
  this.request  =
    new DefaultFullHttpRequest(HttpVersion.HTTP_1_1,
                  HttpMethod.valueOf(method),
                  uri.getPath().toString(), content);
  // setup the default headers
  request.headers().set("Connection", "keep-alive");
  request.headers().set("Host", uri.getHost() + ":"
    + (uri.getPort() != -1 ? uri.getPort() : "http".equals(uri.getScheme()) ? 80 : 443));
}

private String postOrGet(String url, byte /*@Nullable*/ [] content,
    @Nullable String contentType, final HttpProxyConfig httpProxyConfig,
    final @Nullable String passwordOverride) throws Exception {
  URI uri = new URI(url);
  String scheme = checkNotNull(uri.getScheme());
  final boolean ssl = scheme.equalsIgnoreCase("https");
  final String host = checkNotNull(uri.getHost());
  final int port;
  if (uri.getPort() == -1) {
      request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,
          uri.getRawPath());
    } else {
      request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST,
          uri.getRawPath(), Unpooled.wrappedBuffer(content));
      request.headers().set(HttpHeaderNames.CONTENT_TYPE, checkNotNull(contentType));
      request.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.length);
    request.headers().set(HttpHeaderNames.HOST, host);
    request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
    Channel ch = bootstrap.connect(host, port).sync().channel();

String host = requestUri.getHost();
int port = requestUri.getPort() != -1 ? requestUri.getPort() : "https".equals(requestUri.getScheme()) ? 443 : 80;
                       HttpMethod.valueOf(jerseyRequest.getMethod()),
                       requestUri.getRawPath());
  } else {
    nettyRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1,
                         HttpMethod.valueOf(jerseyRequest.getMethod()),
                         requestUri.getRawPath());
    nettyRequest.headers().add(e.getKey(), e.getValue());

private FullHttpRequest createFullHttpRequest(HttpHeaders headers) {
  io.netty.handler.codec.http.HttpMethod nettyMethod =
   io.netty.handler.codec.http.HttpMethod.valueOf(this.method.name());
  FullHttpRequest nettyRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1,
   nettyMethod, this.uri.toString(), this.body.buffer());
  io.netty.handler.codec.http.HttpHeaders nettyHeaders = nettyRequest.headers();
  nettyHeaders.set(HttpHeaders.HOST, this.uri.getHost());
  nettyHeaders.set(HttpHeaders.CONNECTION, "close");
  for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
    nettyHeaders.add(entry.getKey(), entry.getValue());
  }
  return nettyRequest;
}

@Test
public void testBuildWithUriTwoLegs() {
 HttpRequest nettyRequest1 = new DefaultFullHttpRequest(HttpVersion.HTTP_1_0, HttpMethod.GET, "finance");
 RecordedHttpRequestBuilder recordedHttpRequestBuilder = new RecordedHttpRequestBuilder(nettyRequest1);
 HttpRequest nettyRequest2 = new DefaultFullHttpRequest(HttpVersion.HTTP_1_0, HttpMethod.GET, "google.com");
 nettyRequest2.headers().set(HttpHeaders.Names.HOST, "www.google.com/");
 recordedHttpRequestBuilder.addHeaders(nettyRequest2);
 RecordedHttpRequest recordedHttpRequest = recordedHttpRequestBuilder.build();
 Assert.assertEquals(recordedHttpRequest.getUri().toString(), "https://www.google.com/finance");
}

@Path("/")
@GET
public void proxy(RakamHttpRequest request, @QueryParam("u") String uri) throws InterruptedException {
  URI url = UriBuilder.fromUri(uri).build();
  int port;
  if (url.getPort() != -1) {
    port = url.getPort();
  } else if (url.getScheme().equals("http")) {
    port = 80;
  } else if (url.getScheme().equals("https")) {
    port = 443;
  } else {
    request.response("invalid scheme").end();
    return;
  }
  Channel ch = (port == 443 ? sslBootstrap : bootstrap).connect(url.getHost(), port)
      .sync().channel();
  ch.attr(CONNECTION_ATTR).set(request);
  HttpRequest req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, url.getRawPath());
  req.headers().set(HttpHeaders.Names.HOST, url.getHost());
  req.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
  req.headers().set(HttpHeaders.Names.ACCEPT_ENCODING, HttpHeaders.Values.GZIP);
  req.headers().set(HttpHeaders.Names.CACHE_CONTROL, HttpHeaders.Values.NO_CACHE);
  req.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
  req.headers().set(HttpHeaders.Names.PRAGMA, HttpHeaders.Values.NO_CACHE);
  req.headers().set(HttpHeaders.Names.USER_AGENT, "rakam-ab-test-tool 0.1");
  ch.writeAndFlush(req);
}

protected void newNettyRequest(URI uri, HttpMethod method, HttpVersion version) {
  request = new DefaultFullHttpRequest(version, method, uri.getRawPath(), contents);
  headers().set(HttpHeaders.Names.REFERER, originalUri == null ? uri.toString() : originalUri.toString());
}

  final FullHttpRequest request = new DefaultFullHttpRequest(
      HttpVersion.HTTP_1_1, HttpMethod.POST, path,
      Unpooled.wrappedBuffer(out.getArray(), 0, out.length()));
  request.headers().add(HttpHeaderNames.HOST, host);
  request.headers().set(ExtensionHeaderNames.SCHEME.text(), uri.getScheme());
  request.headers().add(defaultHeaders);
  ch.writeAndFlush(request).sync();
  final byte[] array = new byte[response.readableBytes()];
  response.readBytes(array);
  in = new TMemoryInputTransport(array);
  response.release();
} catch (Exception e) {
  throw new TTransportException(TTransportException.UNKNOWN, e);

private DefaultHttpRequest createRequest(HttpRequest request)
    throws IOException {
  HttpMethod method = HttpMethod.valueOf(request.getMethod().name());
  URI uri = request.getURI();
  String url = StringUtil.isBlank(uri.getRawPath()) ? "/" : uri
      .getRawPath();
  if (StringUtil.isNotBlank(uri.getRawQuery())) {
    url += "?" + uri.getRawQuery();
    out.flush();
    out.close();
    uriRequest = new DefaultFullHttpRequest(
        uriRequest.getProtocolVersion(), uriRequest.getMethod(),
        uriRequest.getUri(), byteBuf);
    if (entity.getContentType() != null) {
      uriRequest.headers().add(HttpHeaders.CONTENT_TYPE,
          entity.getContentType().toString());
      uriRequest.headers().add(HttpHeaders.TRANSFER_ENCODING,
          io.netty.handler.codec.http.HttpHeaders.Values.CHUNKED);
    } else {
      uriRequest.headers().add(HttpHeaders.CONTENT_LENGTH,
          entity.getContentLength());

expectedChallengeResponseString = WebSocketUtil.base64(sha1);
if (logger.isDebugEnabled()) {
  logger.debug(
      "WebSocket version 08 client handshake key: {}, expected response: {}",
      key, expectedChallengeResponseString);
FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, path);
HttpHeaders headers = request.headers();
  headers.add(customHeaders);
headers.set(HttpHeaderNames.UPGRADE, HttpHeaderValues.WEBSOCKET)
    .set(HttpHeaderNames.CONNECTION, HttpHeaderValues.UPGRADE)
    .set(HttpHeaderNames.SEC_WEBSOCKET_KEY, key)
    .set(HttpHeaderNames.HOST, websocketHostValue(wsURL))

private HttpRequest prepareEntityRequest(String uri, Object entity, HttpMethod httpMethod) {
  HttpRequest request = null;
  if (entity != null) {
    FullHttpRequest fullRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, httpMethod, uri);
    byte[] bytes;
    try {
      ObjectMapper objectMapper = new ObjectMapper();
      objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
      bytes = objectMapper.writeValueAsBytes(entity);
    } catch (JsonProcessingException e) {
      throw new RuntimeException(e);
    }
    fullRequest.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json");
    fullRequest.content().clear().writeBytes(Unpooled.copiedBuffer(bytes));
    fullRequest.headers().set(HttpHeaderNames.CONTENT_LENGTH, bytes.length);
    request = fullRequest;
  } else {
    request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, httpMethod, uri);
    request.headers().set(HttpHeaderNames.CONTENT_LENGTH, 0);
  }
  setDefaultHeaders(request);
  return request;
}

public static FullHttpRequest newRequest(HttpMethod method, String uri, String body, CharSequence contentType, UserCredentials userCredentials) {
  checkNotNull(method, "method is null");
  checkArgument(!isNullOrEmpty(uri), "uri is null or empty");
  checkNotNull(body, "body is null");
  checkNotNull(contentType, "contentType is null");
  checkArgument(contentType.length() > 0, "contentType is empty");
  ByteBuf data = copiedBuffer(body, UTF_8);
  FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, method, uri, data);
  request.headers().set(HttpHeaderNames.CONTENT_TYPE, contentType);
  request.headers().set(HttpHeaderNames.CONTENT_LENGTH, data.readableBytes());
  if (userCredentials != null) {
    addAuthorizationHeader(request, userCredentials);
  }
  return request;
}

private void testPredictionsJson(Channel channel) throws InterruptedException {
  result = null;
  latch = new CountDownLatch(1);
  DefaultFullHttpRequest req =
      new DefaultFullHttpRequest(
          HttpVersion.HTTP_1_1, HttpMethod.POST, "/predictions/noop");
  req.content().writeCharSequence("{\"data\": \"test\"}", CharsetUtil.UTF_8);
  HttpUtil.setContentLength(req, req.content().readableBytes());
  req.headers().set(HttpHeaderNames.CONTENT_TYPE, HttpHeaderValues.APPLICATION_JSON);
  channel.writeAndFlush(req);
  latch.await();
  Assert.assertEquals(result, "OK");
}

System.arraycopy(number2Array, 0, challenge, 4, 4);
System.arraycopy(key3, 0, challenge, 8, 8);
expectedChallengeResponseBytes = Unpooled.wrappedBuffer(WebSocketUtil.md5(challenge));
FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, path);
HttpHeaders headers = request.headers();
  headers.add(customHeaders);
headers.set(HttpHeaderNames.UPGRADE, WEBSOCKET)
    .set(HttpHeaderNames.CONNECTION, HttpHeaderValues.UPGRADE)
    .set(HttpHeaderNames.HOST, websocketHostValue(wsURL))
    .set(HttpHeaderNames.ORIGIN, websocketOriginValue(wsURL))
headers.set(HttpHeaderNames.CONTENT_LENGTH, key3.length);
request.content().writeBytes(key3);
return request;