com.github.dockerjava.netty.handler.HttpResponseHandler Maven / Gradle / Ivy
package com.github.dockerjava.netty.handler;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpObject;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.LastHttpContent;
import java.nio.charset.Charset;
import com.github.dockerjava.api.async.ResultCallback;
import com.github.dockerjava.api.exception.BadRequestException;
import com.github.dockerjava.api.exception.ConflictException;
import com.github.dockerjava.api.exception.DockerException;
import com.github.dockerjava.api.exception.InternalServerErrorException;
import com.github.dockerjava.api.exception.NotAcceptableException;
import com.github.dockerjava.api.exception.NotFoundException;
import com.github.dockerjava.api.exception.NotModifiedException;
import com.github.dockerjava.api.exception.UnauthorizedException;
/**
* Handler that is responsible to handle an incoming {@link HttpResponse}. It evaluates the status code and triggers the appropriate
* lifecycle methods at the passed {@link ResultCallback}.
*
* @author Marcus Linke
*/
public class HttpResponseHandler extends SimpleChannelInboundHandler {
private HttpResponse response;
private ByteBuf errorBody = Unpooled.buffer();
private HttpRequestProvider requestProvider;
private ResultCallback resultCallback;
public HttpResponseHandler(HttpRequestProvider requestProvider, ResultCallback resultCallback) {
super(false);
this.requestProvider = requestProvider;
this.resultCallback = resultCallback;
}
@Override
protected void channelRead0(final ChannelHandlerContext ctx, HttpObject msg) throws Exception {
if (msg instanceof HttpResponse) {
response = (HttpResponse) msg;
resultCallback.onStart(() -> ctx.channel().close());
} else if (msg instanceof HttpContent) {
HttpContent content = (HttpContent) msg;
ByteBuf byteBuf = content.content();
switch (response.status().code()) {
case 200:
case 201:
case 204:
ctx.fireChannelRead(byteBuf);
break;
default:
errorBody.writeBytes(byteBuf);
}
if (content instanceof LastHttpContent) {
try {
switch (response.status().code()) {
case 101:
case 200:
case 201:
case 204:
break;
case 301:
case 302:
if (response.headers().contains(HttpHeaderNames.LOCATION)) {
String location = response.headers().get(HttpHeaderNames.LOCATION);
HttpRequest redirected = requestProvider.getHttpRequest(location);
ctx.channel().writeAndFlush(redirected);
}
break;
case 304:
throw new NotModifiedException(getBodyAsMessage(errorBody));
case 400:
throw new BadRequestException(getBodyAsMessage(errorBody));
case 401:
throw new UnauthorizedException(getBodyAsMessage(errorBody));
case 404:
throw new NotFoundException(getBodyAsMessage(errorBody));
case 406:
throw new NotAcceptableException(getBodyAsMessage(errorBody));
case 409:
throw new ConflictException(getBodyAsMessage(errorBody));
case 500:
throw new InternalServerErrorException(getBodyAsMessage(errorBody));
default:
throw new DockerException(getBodyAsMessage(errorBody), response.status().code());
}
} catch (Throwable e) {
resultCallback.onError(e);
} finally {
resultCallback.onComplete();
}
}
}
}
private String getBodyAsMessage(ByteBuf body) {
String result = body.readBytes(body.readableBytes()).toString(Charset.forName("UTF-8"));
body.discardReadBytes();
body.release();
return result;
}
}