EntityStream uncompressedStream = compressor.inflate(res.getEntityStream()); StreamResponseBuilder builder = res.builder(); Map<String, String> headers =
EntityStream uncompressedStream = compressor.inflate(response.getEntityStream());
res.getEntityStream().setReader(reader); return;
@Override public void onResponse(TransportResponse<StreamResponse> response) { StreamResponse streamResponse = ServletHelper.writeResponseHeadersToServletResponse(response, resp); streamResponse.getEntityStream().setReader(ioHandler); } };
@Override protected void channelRead0(ChannelHandlerContext ctx, StreamResponse response) throws Exception { final Map<String, String> headers = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); headers.putAll(response.getHeaders()); final Map<String, String> wireAttrs = WireAttributeHelper.removeWireAttributes(headers); final StreamResponse newResponse = new StreamResponseBuilder(response) .unsafeSetHeaders(headers) .build(response.getEntityStream()); // In general there should always be a callback to handle a received message, // but it could have been removed due to a previous exception or closure on the // channel TransportCallback<StreamResponse> callback = ctx.channel().attr(CALLBACK_ATTR_KEY).getAndSet(null); if (callback != null) { LOG.debug("{}: handling a response", ctx.channel().remoteAddress()); callback.onResponse(TransportResponseImpl.success(newResponse, wireAttrs)); } else { LOG.debug("{}: dropped a response", ctx.channel().remoteAddress()); } }
@Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { if (msg instanceof ResponseWithCallback) { @SuppressWarnings("unchecked") ResponseWithCallback<StreamResponse, TransportCallback<StreamResponse>> responseWithCallback = (ResponseWithCallback<StreamResponse, TransportCallback<StreamResponse>>) msg; StreamResponse response = responseWithCallback.response(); TransportCallback<StreamResponse> callback = responseWithCallback.callback(); Map<String, String> headers = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); headers.putAll(response.getHeaders()); Map<String, String> wireAttrs = WireAttributeHelper.removeWireAttributes(headers); StreamResponse newResponse = new StreamResponseBuilder(response) .unsafeSetHeaders(headers) .build(response.getEntityStream()); LOG.debug("{}: handling a response", ctx.channel().remoteAddress()); callback.onResponse(TransportResponseImpl.success(newResponse, wireAttrs)); } ctx.fireChannelRead(msg); }
/** * Converts a StreamResponse to RestResponse * @param streamResponse the stream request to be converted * @param callback the callback to be invoked when the rest response is constructed * @param addContentLengthHeader whether the rest response should have content-length header */ public static void toRestResponse(StreamResponse streamResponse, final Callback<RestResponse> callback, final boolean addContentLengthHeader) { final RestResponseBuilder builder = new RestResponseBuilder(streamResponse); Callback<ByteString> assemblyCallback = new Callback<ByteString>() { @Override public void onError(Throwable e) { callback.onError(e); } @Override public void onSuccess(ByteString result) { if (addContentLengthHeader) { builder.setHeader(HttpConstants.CONTENT_LENGTH, String.valueOf(result.length())); } RestResponse restResponse = builder.setEntity(result).build(); callback.onSuccess(restResponse); } }; streamResponse.getEntityStream().setReader(new FullEntityReader(assemblyCallback)); }
private void trace(final String method, final StreamResponse response, final Map<String, String> wireAttrs, final RequestContext requestContext) { final URI requestUri = (URI)requestContext.getLocalAttr(REQUEST_URI); final String requestMethod = (String)requestContext.getLocalAttr(REQUEST_METHOD); Callback<Integer> callback = new Callback<Integer>() { @Override public void onError(Throwable e) { _log.warn("Cannot get the length of the response", e); } @Override public void onSuccess(Integer result) { _log.debug(buildLogMessage(method, "response", formatResponse(response, result, requestUri, requestMethod), wireAttrs, requestContext)); } }; response.getEntityStream().addObserver(new LengthObserver(callback)); }
@Override public void onStreamResponse(StreamResponse streamResponse, RequestContext requestContext, Map<String, String> wireAttrs, NextFilter<StreamRequest, StreamResponse> nextFilter) { streamResponse.getEntityStream().setReader(new DrainReader()); nextFilter.onResponse(streamResponse.builder().build(EntityStreams.emptyStream()), requestContext, wireAttrs); }
response.getResponse().getEntityStream().addObserver(observer);
EntityStream uncompressedStream = compressor.inflate(res.getEntityStream()); StreamResponseBuilder builder = res.builder(); Map<String, String> headers =
@Override public void onResponse(TransportResponse<StreamResponse> response) { final TransportCallback<StreamResponse> callback = _callbackRef.getAndSet(null); if (callback != null) { final TransportResponse<StreamResponse> wrappedResponse; if (response.hasError()) { wrappedResponse = response; } else { EventLoopConnector connector = new EventLoopConnector(response.getResponse().getEntityStream()); StreamResponse newResponse = response.getResponse().builder().build(EntityStreams.newEntityStream(connector)); wrappedResponse = TransportResponseImpl.success(newResponse, response.getWireAttributes()); } trySchedule(() -> callback.onResponse(wrappedResponse)); } else { LOG.warn("Received response {} while _callback is null. Ignored.", response.getResponse()); } }
EntityStream uncompressedStream = compressor.inflate(response.getEntityStream());
EntityStream entityStream = response.getResponse().getEntityStream();
@Override public void onStreamError(Throwable throwable, RequestContext requestContext, Map<String, String> wireAttrs, NextFilter<StreamRequest, StreamResponse> nextFilter) { if (throwable instanceof StreamException) { StreamException ex = (StreamException) throwable; StreamResponse response = ex.getResponse(); response.getEntityStream().setReader(new DrainReader()); nextFilter.onError(new StreamException(response.builder().build(EntityStreams.emptyStream()), ex.getMessage(), ex.getCause()), requestContext, wireAttrs); } else { nextFilter.onError(throwable, requestContext, wireAttrs); } } });
CompletionStage<DataMap> dataMapCompletionStage = streamDataCodec.decodeMap(EntityStreamAdapters.toGenericEntityStream(streamResponse.getEntityStream())); dataMapCompletionStage.handle((dataMap, e) -> streamResponse.getEntityStream().setReader(fullEntityReader);
res.getEntityStream().setReader(reader); return;