com.github.dockerjava.api.exception.NotModifiedException Java Examples

/**
 * Stop and remove a running container.
 *
 * @param containerID The container ID.
 */
public static void stopContainer(String containerID) {
    try {
        InspectContainerResponse containerInfo = getDockerClient().inspectContainerCmd(containerID).exec();
        if ((null != containerInfo.getState().getRestarting() && containerInfo.getState().getRestarting()) ||
                (null != containerInfo.getState().getPaused() && containerInfo.getState().getPaused()) ||
                (null != containerInfo.getState().getRunning() && containerInfo.getState().getRunning())) {
            log.info("Stopping container: " + containerID);
            getDockerClient().stopContainerCmd(containerID).exec();
        }
        log.info("Removing container: " + containerID);
        getDockerClient().removeContainerCmd(containerID).exec();
    } catch (NotFoundException | NotModifiedException e) {
        // ignore
    }
}
 

@Override
public void filter(ClientRequestContext requestContext, ClientResponseContext responseContext) throws IOException {
    int status = responseContext.getStatus();
    switch (status) {
        case 200:
        case 201:
        case 204:
            return;
        case 304:
            throw new NotModifiedException(getBodyAsMessage(responseContext));
        case 400:
            throw new BadRequestException(getBodyAsMessage(responseContext));
        case 401:
            throw new UnauthorizedException(getBodyAsMessage(responseContext));
        case 404:
            throw new NotFoundException(getBodyAsMessage(responseContext));
        case 406:
            throw new NotAcceptableException(getBodyAsMessage(responseContext));
        case 409:
            throw new ConflictException(getBodyAsMessage(responseContext));
        case 500:
            throw new InternalServerErrorException(getBodyAsMessage(responseContext));
        default:
            throw new DockerException(getBodyAsMessage(responseContext), status);
    }
}
 

protected DockerHttpClient.Response execute(DockerHttpClient.Request request) {
    try {
        DockerHttpClient.Response response = dockerHttpClient.execute(request);
        int statusCode = response.getStatusCode();
        if (statusCode < 200 || statusCode > 299) {
            try {
                String body = IOUtils.toString(response.getBody(), StandardCharsets.UTF_8);
                switch (statusCode) {
                    case 304:
                        throw new NotModifiedException(body);
                    case 400:
                        throw new BadRequestException(body);
                    case 401:
                        throw new UnauthorizedException(body);
                    case 404:
                        throw new NotFoundException(body);
                    case 406:
                        throw new NotAcceptableException(body);
                    case 409:
                        throw new ConflictException(body);
                    case 500:
                        throw new InternalServerErrorException(body);
                    default:
                        throw new DockerException(body, statusCode);
                }
            } finally {
                response.close();
            }
        } else {
            return response;
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

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

/**
 * @throws NotFoundException
 *             No such container
 * @throws NotModifiedException
 *             Container already started
 */
@Override
Void exec() throws NotFoundException, NotModifiedException;
 

/**
 * @throws NotFoundException
 *             No such container
 * @throws NotModifiedException
 *             Container already stopped
 */
@Override
Void exec() throws NotFoundException, NotModifiedException;
 

/**
 * @throws NotFoundException
 *             No such container
 * @throws NotModifiedException
 *             Container already started
 */
@Override
public Void exec() throws NotFoundException, NotModifiedException {
    return super.exec();
}
 

/**
 * @throws NotFoundException
 *             No such container
 * @throws NotModifiedException
 *             Container already stopped
 */
@Override
public Void exec() throws NotFoundException, NotModifiedException {
    return super.exec();
}