/** * Creates a new failed HTTP response. * * @deprecated Use {@link #ofFailure(Throwable)}. */ @Deprecated static HttpResponse ofFailed(Throwable cause) { return ofFailure(cause); }
@Nullable @Override public HttpResponse read(Executor fileReadExecutor, ByteBufAllocator alloc) { try { final HttpFile file = getFile(); return file != null ? file.read(fileReadExecutor, alloc) : null; } catch (Exception e) { return HttpResponse.ofFailure(e); } }
@Override public final HttpResponse read(Executor fileReadExecutor, ByteBufAllocator alloc) { requireNonNull(fileReadExecutor, "fileReadExecutor"); requireNonNull(alloc, "alloc"); try { final HttpFileAttributes attrs = readAttributes(); final HttpHeaders headers = readHeaders(attrs); if (headers == null) { return null; } final long length = attrs.length(); if (length == 0) { // No need to stream an empty file. return HttpResponse.of(headers); } return doRead(headers, length, fileReadExecutor, alloc); } catch (Exception e) { return HttpResponse.ofFailure(e); } }
private HttpResponse execute(@Nullable EventLoop eventLoop, HttpRequest req) { final String concatPaths = concatPaths(uri().getRawPath(), req.path()); req.path(concatPaths); final PathAndQuery pathAndQuery = PathAndQuery.parse(concatPaths); if (pathAndQuery == null) { req.abort(); return HttpResponse.ofFailure(new IllegalArgumentException("invalid path: " + concatPaths)); } return execute(eventLoop, req.method(), pathAndQuery.path(), pathAndQuery.query(), null, req, (ctx, cause) -> { if (ctx != null && !ctx.log().isAvailable(RequestLogAvailability.REQUEST_START)) { // An exception is raised even before sending a request, so abort the request to // release the elements. req.abort(); } return HttpResponse.ofFailure(cause); }); }
@Override public HttpResponse execute(ClientRequestContext ctx, HttpRequest req) throws Exception { if (!isValidPath(req)) { final IllegalArgumentException cause = new IllegalArgumentException("invalid path: " + req.path()); handleEarlyRequestException(ctx, req, cause); return HttpResponse.ofFailure(cause); } final Endpoint endpoint = ctx.endpoint().resolve(ctx) .withDefaultPort(ctx.sessionProtocol().defaultPort()); final EventLoop eventLoop = ctx.eventLoop(); final DecodedHttpResponse res = new DecodedHttpResponse(eventLoop); if (endpoint.hasIpAddr()) { // IP address has been resolved already. acquireConnectionAndExecute(ctx, endpoint, endpoint.ipAddr(), req, res); } else { // IP address has not been resolved yet. final Future<InetSocketAddress> resolveFuture = addressResolverGroup.getResolver(eventLoop) .resolve(InetSocketAddress.createUnresolved(endpoint.host(), endpoint.port())); if (resolveFuture.isDone()) { finishResolve(ctx, endpoint, resolveFuture, req, res); } else { resolveFuture.addListener( (FutureListener<InetSocketAddress>) future -> finishResolve(ctx, endpoint, future, req, res)); } } return res; }
@Override protected HttpResponse doExecute(ClientRequestContext ctx, HttpRequest req, CircuitBreaker circuitBreaker) throws Exception { final HttpResponse response; try { response = delegate().execute(ctx, req); } catch (Throwable cause) { if (needsContentInStrategy) { reportSuccessOrFailure(circuitBreaker, strategyWithContent().shouldReportAsSuccess( ctx, HttpResponse.ofFailure(cause))); } else { reportSuccessOrFailure(circuitBreaker, strategy().shouldReportAsSuccess(ctx, cause)); } throw cause; } if (needsContentInStrategy) { final HttpResponseDuplicator resDuplicator = new HttpResponseDuplicator( response, maxSignalLength(ctx.maxResponseLength()), ctx.eventLoop()); reportSuccessOrFailure(circuitBreaker, strategyWithContent().shouldReportAsSuccess( ctx, resDuplicator.duplicateStream())); return resDuplicator.duplicateStream(true); } ctx.log().addListener(log -> { final Throwable cause = log.isAvailable(RequestLogAvailability.RESPONSE_END) ? log.responseCause() : null; reportSuccessOrFailure(circuitBreaker, strategy().shouldReportAsSuccess(ctx, cause)); }, RequestLogAvailability.RESPONSE_HEADERS); return response; }
return HttpResponse.ofFailure(cause); };