@Override public void onSuccess(EntityStream[] results) { if (results.length == 1) // entity stream is less than threshold { StreamResponse response = res.builder().build(results[0]); nextFilter.onResponse(response, requestContext, wireAttrs); } else { EntityStream compressedStream = compressor.deflate(EntityStreams.newEntityStream(new CompositeWriter(results))); StreamResponseBuilder builder = res.builder(); // remove original content-length header if presents. if (builder.getHeader(HttpConstants.CONTENT_LENGTH) != null) { Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_LENGTH); builder.setHeaders(headers); } StreamResponse response = builder.addHeaderValue(HttpConstants.CONTENT_ENCODING, compressor.getContentEncodingName()) .build(compressedStream); nextFilter.onResponse(response, requestContext, wireAttrs); } } });
Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_ENCODING, HttpConstants.CONTENT_LENGTH); res = builder.setHeaders(headers).build(uncompressedStream);
Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_ENCODING, HttpConstants.CONTENT_LENGTH); response = builder.setHeaders(headers).build(uncompressedStream); ex = new StreamException(response);
StreamResponse streamResponse = new StreamResponseBuilder().setStatus(HttpConstants.UNSUPPORTED_MEDIA_TYPE).build(EntityStreams.emptyStream()); nextFilter.onError(new StreamException(streamResponse, ex), requestContext, wireAttrs);
response = new StreamResponseBuilder().setStatus(HttpConstants.NOT_ACCEPTABLE).build(EntityStreams.emptyStream());
public static StreamResponse simpleStreamResponse() { return new StreamResponseBuilder() .build(EntityStreams.emptyStream()); }
@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); }
/** * Create a StreamResponse based on the RestResponse * @param restResponse the rest response * @return the StreamResponse that's created based on rest response */ public static StreamResponse toStreamResponse(RestResponse restResponse) { StreamResponseBuilder builder = new StreamResponseBuilder(restResponse); return builder.build(EntityStreams.newEntityStream(new ByteStringWriter(restResponse.getEntity()))); }
@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); }
@Override public void onSuccess(EntityStream[] results) { if (results.length == 1) // entity stream is less than threshold { StreamResponse response = res.builder().build(results[0]); nextFilter.onResponse(response, requestContext, wireAttrs); } else { EntityStream compressedStream = compressor.deflate(EntityStreams.newEntityStream(new CompositeWriter(results))); StreamResponseBuilder builder = res.builder(); // remove original content-length header if presents. if (builder.getHeader(HttpConstants.CONTENT_LENGTH) != null) { Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_LENGTH); builder.setHeaders(headers); } StreamResponse response = builder.addHeaderValue(HttpConstants.CONTENT_ENCODING, compressor.getContentEncodingName()) .build(compressedStream); nextFilter.onResponse(response, requestContext, wireAttrs); } } });
Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_ENCODING, HttpConstants.CONTENT_LENGTH); res = builder.setHeaders(headers).build(uncompressedStream);
@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()); } }
Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_ENCODING, HttpConstants.CONTENT_LENGTH); response = builder.setHeaders(headers).build(uncompressedStream); ex = new StreamException(response);
@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); } } });
@Override protected StreamResponse convertResponse(RestLiResponse restLiResponse) throws Exception { StreamResponseBuilder responseBuilder = new StreamResponseBuilder() .setHeaders(restLiResponse.getHeaders()) .setCookies(CookieUtil.encodeSetCookies(restLiResponse.getCookies())) .setStatus(restLiResponse.getStatus().getCode()); EntityStream<ByteString> entityStream = _context.getResponseEntityStream(); if (entityStream != null) { // Unstructured data response // Content-Type is required if (restLiResponse.getHeaders().get(RestConstants.HEADER_CONTENT_TYPE) == null) { throw new RestLiServiceException(HttpStatus.S_500_INTERNAL_SERVER_ERROR, "Content-Type is missing."); } } else { entityStream = EntityStreams.emptyStream(); } return responseBuilder.build(EntityStreamAdapters.fromGenericEntityStream(entityStream)); }
public static StreamException buildStreamException(RestLiResponseException restLiResponseException, StreamDataCodec codec) { RestLiResponse restLiResponse = restLiResponseException.getRestLiResponse(); StreamResponseBuilder responseBuilder = new StreamResponseBuilder() .setHeaders(restLiResponse.getHeaders()) .setCookies(CookieUtil.encodeSetCookies(restLiResponse.getCookies())) .setStatus(restLiResponse.getStatus().getCode()); EntityStream<ByteString> entityStream = codec.encodeMap(restLiResponse.getDataMap()); StreamResponse response = responseBuilder.build(EntityStreamAdapters.fromGenericEntityStream(entityStream)); return new StreamException(response, restLiResponseException.getCause()); } }
StreamResponse streamResponse = new StreamResponseBuilder().setStatus(HttpConstants.UNSUPPORTED_MEDIA_TYPE).build(EntityStreams.emptyStream()); nextFilter.onError(new StreamException(streamResponse, ex), requestContext, wireAttrs);
response = new StreamResponseBuilder().setStatus(HttpConstants.NOT_ACCEPTABLE).build(EntityStreams.emptyStream());
@Override protected StreamResponse convertResponse(RestLiResponse restLiResponse) throws Exception { StreamResponseBuilder responseBuilder = new StreamResponseBuilder() .setHeaders(restLiResponse.getHeaders()) .setCookies(CookieUtil.encodeSetCookies(restLiResponse.getCookies())) .setStatus(restLiResponse.getStatus().getCode()); EntityStream<ByteString> entityStream; if (restLiResponse.hasData()) { responseBuilder.setHeader(RestConstants.HEADER_CONTENT_TYPE, _contentType.getHeaderKey()); entityStream = _contentType.getStreamCodec().encodeMap(restLiResponse.getDataMap()); } else { entityStream = EntityStreams.emptyStream(); } return responseBuilder.build(EntityStreamAdapters.fromGenericEntityStream(entityStream)); }