下面列出了怎么用 io.netty.handler.codec.http.DefaultHttpResponse 的API类实例代码及写法，或者点击链接到github查看源代码。
public void sendChunkedHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res) {
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
HttpUtil.setTransferEncodingChunked(response, true);
response.headers().set(HttpHeaderNames.CONTENT_TYPE, res.headers().get(HttpHeaderNames.CONTENT_TYPE));
if(HttpUtil.isKeepAlive(req)) {
response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
}
ctx.write(response);
ctx.write(new ChunkedStream(new ByteBufInputStream(res.content())));
ChannelFuture future = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
if(!HttpUtil.isKeepAlive(req)) {
future.addListener(ChannelFutureListener.CLOSE);
}
metrics.incHTTPResponseCounter(className, res.status().code());
}
@Override
protected HttpMessage createMessage(final String[] initialLine)
throws Exception {
// If the first element of the initial line is a version string then
// this is a response
if (versionPattern.matcher(initialLine[0]).matches()) {
isDecodingRequest = false;
return new DefaultHttpResponse(RtspVersions.valueOf(initialLine[0]),
new HttpResponseStatus(Integer.parseInt(initialLine[1]),
initialLine[2]),
validateHeaders);
} else {
isDecodingRequest = true;
return new DefaultHttpRequest(RtspVersions.valueOf(initialLine[2]),
RtspMethods.valueOf(initialLine[0]),
initialLine[1],
validateHeaders);
}
}
/**
* Test of a 200 OK response, without body.
*/
@Test
public void testSend200OkResponseWithoutBody() {
String expected = "RTSP/1.0 200 OK\r\n"
+ "server: Testserver\r\n"
+ "cseq: 1\r\n"
+ "session: 2547019973447939919\r\n"
+ "\r\n";
HttpResponse response = new DefaultHttpResponse(RtspVersions.RTSP_1_0,
RtspResponseStatuses.OK);
response.headers().add(RtspHeaderNames.SERVER, "Testserver");
response.headers().add(RtspHeaderNames.CSEQ, "1");
response.headers().add(RtspHeaderNames.SESSION, "2547019973447939919");
EmbeddedChannel ch = new EmbeddedChannel(new RtspEncoder());
ch.writeOutbound(response);
ByteBuf buf = ch.readOutbound();
String actual = buf.toString(CharsetUtil.UTF_8);
buf.release();
assertEquals(expected, actual);
}
/**
* Create a new object to contain the response data.
*
* @param streamId The stream associated with the response
* @param http2Headers The initial set of HTTP/2 headers to create the response with
* @param validateHttpHeaders <ul>
* <li>{@code true} to validate HTTP headers in the http-codec</li>
* <li>{@code false} not to validate HTTP headers in the http-codec</li>
* </ul>
* @return A new response object which represents headers for a chunked response
* @throws Http2Exception see {@link #addHttp2ToHttpHeaders(int, Http2Headers,
* HttpHeaders, HttpVersion, boolean, boolean)}
*/
public static HttpResponse toHttpResponse(final int streamId,
final Http2Headers http2Headers,
final boolean validateHttpHeaders) throws Http2Exception {
final HttpResponseStatus status = parseStatus(http2Headers.status());
// HTTP/2 does not define a way to carry the version or reason phrase that is included in an
// HTTP/1.1 status line.
final HttpResponse msg = new DefaultHttpResponse(HttpVersion.HTTP_1_1, status, validateHttpHeaders);
try {
addHttp2ToHttpHeaders(streamId, http2Headers, msg.headers(), msg.protocolVersion(), false, true);
} catch (final Http2Exception e) {
throw e;
} catch (final Throwable t) {
throw streamError(streamId, PROTOCOL_ERROR, t, "HTTP/2 to HTTP/1.x headers conversion error");
}
return msg;
}
public static void write(ChannelHandlerContext ctx, SessionContext sctx, WebRequest request, WebView webView) {
try {
DefaultHttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1,
HttpResponseStatus.valueOf(webView.getStatus()));
if (HttpUtil.isKeepAlive(request.getHttpRequest())) {
response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
}
response.headers().set(HttpHeaderNames.CONTENT_TYPE, webView.getContentType());
response.headers().set(HttpHeaderNames.CONTENT_LENGTH, webView.getLength());
response.headers().set(HttpHeaderNames.SERVER, Summer.NAME);
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
if (sctx.getSessionId() == null) {
response.headers().set(HttpHeaderNames.SET_COOKIE, createSessionId());
}
if (webView.getHeaders() != null) {
webView.getHeaders().forEach((key, value) -> response.headers().set(key, value));
}
ctx.write(response);
ctx.write(webView.getChunkedInput());
ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
private void sendSnapshotImage(ChannelHandlerContext ctx, String contentType) throws IOException {
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
if (ipCameraGroupHandler.cameraIndex >= ipCameraGroupHandler.cameraOrder.size()) {
logger.debug("WARN: Openhab may still be starting, or all cameras in the group are OFFLINE.");
return;
}
ipCameraGroupHandler.cameraOrder.get(ipCameraGroupHandler.cameraIndex).lockCurrentSnapshot.lock();
ByteBuf snapshotData = Unpooled
.copiedBuffer(ipCameraGroupHandler.cameraOrder.get(ipCameraGroupHandler.cameraIndex).currentSnapshot);
ipCameraGroupHandler.cameraOrder.get(ipCameraGroupHandler.cameraIndex).lockCurrentSnapshot.unlock();
response.headers().add(HttpHeaderNames.CONTENT_TYPE, contentType);
response.headers().set(HttpHeaderNames.CACHE_CONTROL, HttpHeaderValues.NO_CACHE);
response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
response.headers().add(HttpHeaderNames.CONTENT_LENGTH, snapshotData.readableBytes());
response.headers().add("Access-Control-Allow-Origin", "*");
response.headers().add("Access-Control-Expose-Headers", "*");
ctx.channel().write(response);
ctx.channel().write(snapshotData);
ByteBuf footerBbuf = Unpooled.copiedBuffer("\r\n", 0, 2, StandardCharsets.UTF_8);
ctx.channel().writeAndFlush(footerBbuf);
}
private void sendFile(ChannelHandlerContext ctx, String fileUri, String contentType) throws IOException {
logger.debug("file is :{}", fileUri);
File file = new File(fileUri);
ChunkedFile chunkedFile = new ChunkedFile(file);
ByteBuf footerBbuf = Unpooled.copiedBuffer("\r\n", 0, 2, StandardCharsets.UTF_8);
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
response.headers().add(HttpHeaderNames.CONTENT_TYPE, contentType);
response.headers().set(HttpHeaderNames.CACHE_CONTROL, HttpHeaderValues.NO_CACHE);
response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
response.headers().add(HttpHeaderNames.CONTENT_LENGTH, chunkedFile.length());
response.headers().add("Access-Control-Allow-Origin", "*");
response.headers().add("Access-Control-Expose-Headers", "*");
ctx.channel().write(response);
ctx.channel().write(chunkedFile);
ctx.channel().writeAndFlush(footerBbuf);
}
private void sendSnapshotImage(ChannelHandlerContext ctx, String contentType) throws IOException {
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
ipCameraHandler.lockCurrentSnapshot.lock();
ByteBuf snapshotData = Unpooled.copiedBuffer(ipCameraHandler.currentSnapshot);
ipCameraHandler.lockCurrentSnapshot.unlock();
response.headers().add(HttpHeaderNames.CONTENT_TYPE, contentType);
response.headers().set(HttpHeaderNames.CACHE_CONTROL, HttpHeaderValues.NO_CACHE);
response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
response.headers().add(HttpHeaderNames.CONTENT_LENGTH, snapshotData.readableBytes());
response.headers().add("Access-Control-Allow-Origin", "*");
response.headers().add("Access-Control-Expose-Headers", "*");
ctx.channel().write(response);
ctx.channel().write(snapshotData);
ByteBuf footerBbuf = Unpooled.copiedBuffer("\r\n", 0, 2, StandardCharsets.UTF_8);
ctx.channel().writeAndFlush(footerBbuf);
}
@Test(groups = { "unit" })
public void verifyConversionOfHttpResponseHeadersToMap() throws UnsupportedEncodingException {
HttpHeaders headersMap = new DefaultHttpHeaders();
headersMap.add(HttpConstants.HttpHeaders.OWNER_FULL_NAME, OWNER_FULL_NAME_VALUE);
HttpResponse httpResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_0,
HttpResponseStatus.ACCEPTED,
headersMap);
HttpResponseHeaders httpResponseHeaders = new HttpClientResponse(httpResponse, null).getHeaders();
Set<Entry<String, String>> resultHeadersSet = HttpUtils.asMap(httpResponseHeaders).entrySet();
assertThat(resultHeadersSet.size()).isEqualTo(1);
Entry<String, String> entry = resultHeadersSet.iterator().next();
assertThat(entry.getKey()).isEqualTo(HttpConstants.HttpHeaders.OWNER_FULL_NAME);
assertThat(entry.getValue()).isEqualTo(HttpUtils.urlDecode(OWNER_FULL_NAME_VALUE));
List<Entry<String, String>> resultHeadersList = HttpUtils.unescape(httpResponseHeaders.entries());
assertThat(resultHeadersList.size()).isEqualTo(1);
entry = resultHeadersSet.iterator().next();
assertThat(entry.getKey()).isEqualTo(HttpConstants.HttpHeaders.OWNER_FULL_NAME);
assertThat(entry.getValue()).isEqualTo(HttpUtils.urlDecode(OWNER_FULL_NAME_VALUE));
}
public HttpClientResponse<ByteBuf> asHttpClientResponse() {
if (this.networkFailure != null) {
return null;
}
HttpClientResponse<ByteBuf> resp = Mockito.mock(HttpClientResponse.class);
Mockito.doReturn(HttpResponseStatus.valueOf(status)).when(resp).getStatus();
Mockito.doReturn(Observable.just(ByteBufUtil.writeUtf8(ByteBufAllocator.DEFAULT, content))).when(resp).getContent();
DefaultHttpResponse httpResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.valueOf(status), httpHeaders);
try {
Constructor<HttpResponseHeaders> constructor = HttpResponseHeaders.class.getDeclaredConstructor(HttpResponse.class);
constructor.setAccessible(true);
HttpResponseHeaders httpResponseHeaders = constructor.newInstance(httpResponse);
Mockito.doReturn(httpResponseHeaders).when(resp).getHeaders();
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException | NoSuchMethodException | SecurityException e) {
throw new IllegalStateException("Failed to instantiate class object.", e);
}
return resp;
}
@Override
public void beforeRequest(Channel clientChannel, HttpRequest httpRequest, HttpProxyInterceptPipeline pipeline) throws Exception {
String acceptValue = httpRequest.headers().get(HttpHeaderNames.ACCEPT);
if (acceptValue != null && acceptValue.contains("application/x-sniff-cookie")) {
HttpResponse httpResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, new DefaultHttpHeaders());
httpResponse.headers().set(HttpHeaderNames.CONTENT_LENGTH, 0);
//https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Access-Control-Expose-Headers
AsciiString customHeadKey = AsciiString.cached("X-Sniff-Cookie");
String cookie = pipeline.getHttpRequest().headers().get(HttpHeaderNames.COOKIE);
httpResponse.headers().set(customHeadKey, cookie == null ? "" : cookie);
httpResponse.headers().set(HttpHeaderNames.ACCESS_CONTROL_EXPOSE_HEADERS, customHeadKey);
String origin = httpRequest.headers().get(HttpHeaderNames.ORIGIN);
if (StringUtil.isNullOrEmpty(origin)) {
String referer = httpRequest.headers().get(HttpHeaderNames.REFERER);
URL url = new URL(referer);
origin = url.getHost();
}
httpResponse.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, origin);
httpResponse.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_CREDENTIALS, true);
clientChannel.writeAndFlush(httpResponse);
clientChannel.writeAndFlush(new DefaultLastHttpContent());
clientChannel.close();
} else {
super.beforeRequest(clientChannel, httpRequest, pipeline);
}
}
/**
* Return http response with status, body, content type, and custom headers.
*
* @param status http status
* @param body body ByteBuf
* @param contentType content type of response
* @param customHeaders if non-null these headers will be added to the response
*/
default HttpResponse createResponse(
HttpResponseStatus status,
ByteBuf body,
CharSequence contentType,
Map<String, String> customHeaders) {
HttpResponse response =
body == null || body.readableBytes() <= 0
? new DefaultHttpResponse(HttpVersion.HTTP_1_1, status)
: new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, body);
if (customHeaders != null) {
customHeaders.forEach((key, value) -> response.headers().set(key, value));
}
response.headers().set(CONTENT_TYPE, contentType);
response.headers().setInt(CONTENT_LENGTH, body == null ? 0 : body.readableBytes());
return response;
}
private Flux<HttpObject> channelRequestResponse(Channel channel, FullHttpRequest request) {
return Flux.create(sink -> {
channel.pipeline().addLast(new SimpleChannelInboundHandler<HttpObject>() {
@Override
protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
sink.next(msg);
if (msg instanceof DefaultHttpResponse) {
DefaultHttpResponse response = (DefaultHttpResponse) msg;
if (response.decoderResult().isFailure()) {
sink.error(response.decoderResult().cause());
}
}
if (msg instanceof LastHttpContent) {
sink.complete();
}
}
});
channel.writeAndFlush(request);
});
}
private void onCreate(ChannelHandlerContext ctx)
throws IOException, URISyntaxException {
writeContinueHeader(ctx);
final String nnId = params.namenodeId();
final int bufferSize = params.bufferSize();
final short replication = params.replication();
final long blockSize = params.blockSize();
final FsPermission permission = params.permission();
EnumSet<CreateFlag> flags = params.overwrite() ?
EnumSet.of(CreateFlag.CREATE, CreateFlag.OVERWRITE)
: EnumSet.of(CreateFlag.CREATE);
final DFSClient dfsClient = newDfsClient(nnId, confForCreate);
OutputStream out = dfsClient.createWrappedOutputStream(dfsClient.create(
path, permission, flags, replication,
blockSize, null, bufferSize, null), null);
DefaultHttpResponse resp = new DefaultHttpResponse(HTTP_1_1, CREATED);
final URI uri = new URI(HDFS_URI_SCHEME, nnId, path, null, null);
resp.headers().set(LOCATION, uri.toString());
resp.headers().set(CONTENT_LENGTH, 0);
ctx.pipeline().replace(this, HdfsWriter.class.getSimpleName(),
new HdfsWriter(dfsClient, out, resp));
}
@Before
public void setUp() throws Exception {
executeFuture = new CompletableFuture<>();
fullHttpResponse = mock(DefaultHttpContent.class);
when(fullHttpResponse.content()).thenReturn(new EmptyByteBuf(ByteBufAllocator.DEFAULT));
requestContext = new RequestContext(channelPool,
eventLoopGroup,
AsyncExecuteRequest.builder().responseHandler(responseHandler).build(),
null);
channel = new MockChannel();
channel.attr(PROTOCOL_FUTURE).set(CompletableFuture.completedFuture(Protocol.HTTP1_1));
channel.attr(REQUEST_CONTEXT_KEY).set(requestContext);
channel.attr(EXECUTE_FUTURE_KEY).set(executeFuture);
when(ctx.channel()).thenReturn(channel);
nettyResponseHandler = ResponseHandler.getInstance();
DefaultHttpResponse defaultFullHttpResponse = mock(DefaultHttpResponse.class);
when(defaultFullHttpResponse.headers()).thenReturn(EmptyHttpHeaders.INSTANCE);
when(defaultFullHttpResponse.status()).thenReturn(HttpResponseStatus.CREATED);
when(defaultFullHttpResponse.protocolVersion()).thenReturn(HttpVersion.HTTP_1_1);
nettyResponseHandler.channelRead0(ctx, defaultFullHttpResponse);
}
/**
* 处理Http请求，完成WebSocket握手<br/>
* 注意：WebSocket连接第一次请求使用的是Http
*
* @param ctx
* @param request
* @throws Exception
*/
private void handleHttpRequest(ChannelHandlerContext ctx, HttpRequest request)
throws Exception {
// 如果HTTP解码失败，返回HHTP异常
if (!request.getDecoderResult().isSuccess()
|| (!"websocket".equals(request.headers().get("Upgrade")))) {
sendHttpResponse(ctx, request,
new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
return;
}
// 正常WebSocket的Http连接请求，构造握手响应返回
WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
"ws://" + request.headers().get(HttpHeaders.Names.HOST), null, false);
handshaker = wsFactory.newHandshaker(request);
if (handshaker == null) {
// 无法处理的websocket版本
WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
} else {
// 向客户端发送websocket握手,完成握手
logger.debug("向客户端发送websocket握手,完成握手");
handshaker.handshake(ctx.channel(), request);
}
}
private List<HttpObject> handleChunkedResponse(int desiredResponseStatusCode, boolean responseShouldBeEmpty) {
HttpResponse firstChunk = new DefaultHttpResponse(
HttpVersion.HTTP_1_1,
HttpResponseStatus.valueOf(desiredResponseStatusCode)
);
firstChunk.headers()
.set(TRANSFER_ENCODING, CHUNKED)
.set(CONNECTION, HttpHeaders.Values.KEEP_ALIVE)
.set(SOME_EXPECTED_RESPONSE_HEADER.getKey(), SOME_EXPECTED_RESPONSE_HEADER.getValue());
List<HttpObject> responseChunks = new ArrayList<>();
responseChunks.add(firstChunk);
if (!responseShouldBeEmpty) {
RESPONSE_PAYLOAD_CHUNKS.forEach(chunkData -> responseChunks.add(
new DefaultHttpContent(Unpooled.wrappedBuffer(chunkData.getBytes(CharsetUtil.UTF_8)))
));
}
responseChunks.add(LastHttpContent.EMPTY_LAST_CONTENT);
return responseChunks;
}
HttpServerOperations(Connection c,
ConnectionObserver listener,
@Nullable BiPredicate<HttpServerRequest, HttpServerResponse> compressionPredicate,
HttpRequest nettyRequest,
@Nullable ConnectionInfo connectionInfo,
ServerCookieEncoder encoder,
ServerCookieDecoder decoder) {
super(c, listener);
this.nettyRequest = nettyRequest;
this.path = resolvePath(nettyRequest.uri());
this.nettyResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
this.responseHeaders = nettyResponse.headers();
this.responseHeaders.set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED);
this.compressionPredicate = compressionPredicate;
this.cookieHolder = Cookies.newServerRequestHolder(requestHeaders(), decoder);
this.connectionInfo = connectionInfo;
this.cookieEncoder = encoder;
this.cookieDecoder = decoder;
}
@Test
public void testMesosStreamIdIsNotSavedForUnsuccessfulSubscribeCall() throws Exception {
final AtomicReference<String> mesosStreamId = new AtomicReference<>(null);
final Func1<HttpClientResponse<ByteBuf>, Observable<ByteBuf>> f = MesosClient.verifyResponseOk(
"Subscribe",
mesosStreamId,
StringMessageCodec.UTF8_STRING.mediaType()
);
final DefaultHttpResponse nettyResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST);
nettyResponse.headers().add("Mesos-Stream-Id", "streamId");
nettyResponse.headers().add("Content-Type", StringMessageCodec.UTF8_STRING.mediaType());
final HttpClientResponse<ByteBuf> response = new HttpClientResponse<>(
nettyResponse,
UnicastContentSubject.create(1000, TimeUnit.MILLISECONDS)
);
try {
f.call(response);
} catch (Mesos4xxException e) {
// expected
}
assertThat(mesosStreamId.get()).isEqualTo(null);
}
@Override
public void sendResponse(FullHttpRequest req, ChannelHandlerContext ctx) throws Exception {
long startTime = System.nanoTime();
HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(req);
try {
String place = null;
int num = 0;
while(decoder.hasNext()) {
num++;
InterfaceHttpData httpData = decoder.next();
if(httpData.getHttpDataType() == HttpDataType.Attribute && httpData.getName().equalsIgnoreCase("place")) {
place = ((Attribute) httpData).getValue();
} else if(httpData.getHttpDataType() == HttpDataType.FileUpload) {
String camProtAddr = URLDecoder.decode(httpData.getName(), "UTF-8");
Device d = findCamera(camProtAddr);
if(d == null) {
UPLOAD_UNKNOWN.inc();
logger.warn("ignoring preview upload for non-existent camera {}", camProtAddr);
continue;
}
write(place, d, (FileUpload) httpData);
}
}
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
ChannelFuture future = ctx.writeAndFlush(response);
if(!HttpHeaders.isKeepAlive(req)) {
future.addListener(ChannelFutureListener.CLOSE);
}
UPLOAD_NUM.update(num);
UPLOAD_SUCCESS.update(System.nanoTime() - startTime, TimeUnit.NANOSECONDS);
} catch (Exception ex) {
UPLOAD_FAIL.update(System.nanoTime() - startTime, TimeUnit.NANOSECONDS);
} finally {
decoder.cleanFiles();
}
}
public static HttpResponse newUpgradeResponse(String ext) {
HttpResponse res = new DefaultHttpResponse(
HttpVersion.HTTP_1_1, HttpResponseStatus.SWITCHING_PROTOCOLS);
res.headers().set(HttpHeaderNames.HOST, "server.example.com");
res.headers().set(HttpHeaderNames.UPGRADE, HttpHeaderValues.WEBSOCKET.toString().toLowerCase());
res.headers().set(HttpHeaderNames.CONNECTION, "Upgrade");
res.headers().set(HttpHeaderNames.ORIGIN, "http://example.com");
if (ext != null) {
res.headers().set(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS, ext);
}
return res;
}
@Test (expected = EncoderException.class)
public void encodeNonFullHttpResponse100ContinueIsRejected() throws Exception {
EmbeddedChannel ch = new EmbeddedChannel(new Http2StreamFrameToHttpObjectCodec(true));
try {
ch.writeOutbound(new DefaultHttpResponse(
HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE));
} finally {
ch.finishAndReleaseAll();
}
}
@Test
public void testUpgradeHeaders() throws Exception {
EmbeddedChannel ch = new EmbeddedChannel(new Http2StreamFrameToHttpObjectCodec(true));
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
assertTrue(ch.writeOutbound(response));
Http2HeadersFrame headersFrame = ch.readOutbound();
assertThat(headersFrame.headers().status().toString(), is("200"));
assertFalse(headersFrame.isEndStream());
assertThat(ch.readOutbound(), is(nullValue()));
assertFalse(ch.finish());
}
/**
* Duplicates the status line and headers of an HttpResponse object. Does not duplicate any content associated with that response.
*
* @param originalResponse HttpResponse to be duplicated
* @return a new HttpResponse with the same status line and headers
*/
public static HttpResponse duplicateHttpResponse(HttpResponse originalResponse) {
DefaultHttpResponse newResponse = new DefaultHttpResponse(originalResponse.getProtocolVersion(), originalResponse.getStatus());
newResponse.headers().add(originalResponse.headers());
return newResponse;
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable e) throws Exception {
if (e.getCause() instanceof TooLongFrameException) {
DefaultHttpResponse response = new DefaultHttpResponse(HTTP_1_1, REQUEST_ENTITY_TOO_LARGE);
ctx.write(response).addListener(ChannelFutureListener.CLOSE);
} else {
if (ctx.channel().isActive()) { // 连接已断开就不打印了
logger.warn("Exception caught by request handler", e);
}
ctx.close();
}
}
@Override
protected HttpMessage createMessage(String[] initialLine) throws Exception {
return isDecodingRequest() ? new DefaultHttpRequest(
HttpVersion.valueOf(initialLine[2]),
HttpMethod.valueOf(initialLine[0]), initialLine[1], validateHeaders) :
new DefaultHttpResponse(
HttpVersion.valueOf(initialLine[0]),
HttpResponseStatus.valueOf(Integer.parseInt(initialLine[1]), initialLine[2]), validateHeaders);
}
@Test
public void testGetUriFromRedirectResponse_404() throws Exception {
final URI mesosUri = URI.create("http://127.1.0.1:5050/api/v1/scheduler");
final DefaultHttpResponse nettyResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND);
final HttpClientResponse<ByteBuf> response = new HttpClientResponse<>(
nettyResponse,
UnicastContentSubject.create(1000, TimeUnit.MILLISECONDS)
);
final URI uri = MesosClient.getUriFromRedirectResponse(mesosUri, response);
assertThat(uri).isEqualTo(URI.create("http://127.1.0.1:5050/api/v1/scheduler"));
}
@BeforeClass
public void setUp() throws IOException {
HttpCarbonMessage httpCarbonMessage =
new HttpCarbonMessage(new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK));
response = new Response(httpCarbonMessage);
response.setStatus(200);
httpResponse = new TraceableHttpServerResponse(response);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable e)
throws Exception {
// handle the case of to big requests.
if (e.getCause() instanceof TooLongFrameException) {
DefaultHttpResponse response = new DefaultHttpResponse(HTTP_1_1, REQUEST_ENTITY_TOO_LARGE);
ctx.write(response).addListener(ChannelFutureListener.CLOSE);
} else {
if (ctx.channel().isActive()) { // 连接已断开就不打印了
logger.warn("Exception caught by request handler", e);
}
ctx.close();
}
}
public void sendMjpegFirstPacket(ChannelHandlerContext ctx) {
final String BOUNDARY = "thisMjpegStream";
String contentType = "multipart/x-mixed-replace; boundary=" + BOUNDARY;
HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
response.headers().add(HttpHeaderNames.CONTENT_TYPE, contentType);
response.headers().set(HttpHeaderNames.CACHE_CONTROL, HttpHeaderValues.NO_CACHE);
response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
response.headers().add("Access-Control-Allow-Origin", "*");
response.headers().add("Access-Control-Expose-Headers", "*");
ctx.channel().writeAndFlush(response);
}