protected HttpResponseMessage createHttpResponseMessage(HttpResponse ribbonResp, HttpRequestMessage request) { // Convert to a zuul response object. HttpResponseMessage respMsg = new HttpResponseMessage(request.getContext(), request, 500); respMsg.setStatus(ribbonResp.getStatus()); for (Map.Entry<String, String> header : ribbonResp.getHttpHeaders().getAllHeaders()) { if (ProxyUtils.isValidResponseHeader(header.getKey())) { respMsg.getHeaders().add(header.getKey(), header.getValue()); } } // Body. Observable<ByteBuf> responseBodyObs = ByteBufUtils.fromInputStream(ribbonResp.getInputStream()); respMsg.setBodyStream(responseBodyObs); return respMsg; }
@Override public void handle(HttpResponseMessage response) { HttpRequestMessage request = response.getRequest(); SessionContext context = response.getContext(); long duration = context.getTimings().getRequest().getDuration(); int responseBodySize = response.getBody() == null ? 0 : response.getBody().length; // Write to access log. accessLogPublisher.publish(new SimpleAccessRecord(LocalDateTime.now(), response.getStatus(), request.getMethod(), request.getPathAndQuery(), duration, responseBodySize, request.getHeaders(), response.getHeaders() )); // Publish request-level metrics. if (requestMetricsPublisher != null) { requestMetricsPublisher.collectAndPublish(context); } } }
public HttpResponseMessage handle(HttpRequestMessage request) { HttpResponseMessage response = new HttpResponseMessage(request.getContext(), request, 200); response.getHeaders().set("Content-Type", "text/plain"); response.setBody("OK".getBytes(CS_UTF8)); return response; } }
public static HttpResponseMessage clientResponseToZuulResponse(HttpRequestMessage zuulRequest, HttpClientResponse<ByteBuf> resp) { HttpResponseMessage zuulResp = new HttpResponseMessage(zuulRequest.getContext(), zuulRequest, 500); // Copy the response headers and info into the RequestContext for use by post filters. if (resp.getStatus() != null) { zuulResp.setStatus(resp.getStatus().code()); } Headers zuulRespHeaders = zuulResp.getHeaders(); for (Map.Entry<String, String> entry : resp.getHeaders().entries()) { // TODO - should we be filtering headers here like we do when using Ribbon? zuulRespHeaders.add(entry.getKey(), entry.getValue()); } return zuulResp; }
@Test public void testSetResponse() throws Exception { RibbonOrigin origin = new RibbonOrigin("blah"); origin = Mockito.spy(origin); CaseInsensitiveMultiMap headers = new CaseInsensitiveMultiMap(); headers.addHeader("test", "test"); headers.addHeader("content-length", "100"); byte[] body = "test-body".getBytes("UTF-8"); InputStream inp = new ByteArrayInputStream(body); Mockito.when(proxyResp.getStatus()).thenReturn(200); Mockito.when(proxyResp.getInputStream()).thenReturn(inp); Mockito.when(proxyResp.hasEntity()).thenReturn(true); Mockito.when(proxyResp.getHttpHeaders()).thenReturn(headers); HttpResponseMessage response = origin.createHttpResponseMessage(proxyResp, request); Assert.assertEquals(200, response.getStatus()); byte[] respBodyBytes = ByteBufUtils.toBytes(response.getBodyStream().toBlocking().single()); Assert.assertNotNull(respBodyBytes); Assert.assertEquals(body.length, respBodyBytes.length); Assert.assertTrue(response.getHeaders().contains("test", "test")); } }
@Before public void before() throws Exception { MonitoringHelper.initMocks(); MockitoAnnotations.initMocks(this); contextFactory = new ServletSessionContextFactory(); servlet = new ZuulServlet(); servlet.contextFactory = contextFactory; servlet = spy(servlet); servlet.processor = processor; when(servletRequest.getHeaderNames()).thenReturn(Collections.<String>emptyEnumeration()); when(servletRequest.getAttributeNames()).thenReturn(Collections.<String>emptyEnumeration()); servletInputStream = new ServletInputStreamWrapper("{}".getBytes()); when(servletRequest.getInputStream()).thenReturn(servletInputStream); when(servletResponse.getOutputStream()).thenReturn(servletOutputStream); //when(contextFactory.create(context, servletRequest)).thenReturn(Observable.just(request)); response = new HttpResponseMessage(context, request, 299); response.setBody("blah".getBytes()); when(processor.applyInboundFilters(Matchers.any())).thenReturn(Observable.just(request)); when(processor.applyEndpointFilter(Matchers.any())).thenReturn(Observable.just(response)); when(processor.applyOutboundFilters(Matchers.any())).thenReturn(Observable.just(response)); }
servletResponse.setStatus(response.getStatus()); for (Map.Entry<String, String> header : response.getHeaders().entries()) { servletResponse.setHeader(header.getKey(), header.getValue());
@Test public void testService() throws Exception { when(servletRequest.getMethod()).thenReturn("get"); when(servletRequest.getRequestURI()).thenReturn("/some/where?k1=v1"); response.getHeaders().set("new", "value"); servlet.service(servletRequest, servletResponse); verify(servletResponse).setStatus(299); verify(servletResponse).setHeader("new", "value"); } }
protected Observable<HttpResponseMessage> bufferHttpClientResponse(HttpRequestMessage zuulReq, Observable<HttpClientResponse<ByteBuf>> clientResp) { return clientResp.map(resp -> { HttpResponseMessage zuulResp = RxNettyUtils.clientResponseToZuulResponse(zuulReq, resp); //PublishSubject<ByteBuf> cachedContent = PublishSubject.create(); UnicastDisposableCachingSubject<ByteBuf> cachedContent = UnicastDisposableCachingSubject.create(); // Subscribe to the response-content observable (retaining the ByteBufS first). Observable<ByteBuf> content = resp.getContent(); content.map(ByteBuf::retain).subscribe(cachedContent); // Store this content ref on the zuul response object. zuulResp.setBodyStream(cachedContent); return zuulResp; }); } }
response = new HttpResponseMessage(context, (HttpRequestMessage) request, 500);
@Override public Observable<ZuulMessage> write(ZuulMessage msg, HttpServerResponse nativeResponse) { HttpResponseMessage zuulResp = (HttpResponseMessage) msg; // Set the response status code. nativeResponse.setStatus(HttpResponseStatus.valueOf(zuulResp.getStatus())); // Now set all of the response headers - note this is a multi-set in keeping with HTTP semantics for (Map.Entry<String, String> entry : zuulResp.getHeaders().entries()) { nativeResponse.getHeaders().add(entry.getKey(), entry.getValue()); } // Write response body stream as received. Observable<ZuulMessage> chain; Observable<ByteBuf> bodyStream = zuulResp.getBodyStream(); if (bodyStream != null) { chain = bodyStream .doOnNext(bb -> nativeResponse.writeBytesAndFlush(bb)) .ignoreElements() .doOnCompleted(() -> nativeResponse.close()) .map(bb -> msg); } else { chain = Observable.just(msg); } return chain; }