@Override public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) { return client.handle(request, context); }
@Override default Observable<HttpResponse> handle(HttpRequest request, HttpInterceptor.Context context) { return handle(request); }
@Override public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) { return routes.get(request.path()) .orElse(NOT_FOUND_HANDLER) .handle(request, context); }
@Override public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) { return router.route(request, context) .map(pipeline -> pipeline.handle(request, context)) .orElseGet(() -> Eventual.error(new NoServiceConfiguredException(request.path()))); } }
@Override public Observable<HttpResponse> handle(HttpRequest request) { if (!method.equals(request.method())) { return Observable.just( response(METHOD_NOT_ALLOWED) .body(errorBody) .build()); } return httpHandler.handle(request); } }
@Test public void delegatesTheRequestIfRequestMethodIsSupported() { HttpHandler handler = mock(HttpHandler.class); HttpMethodFilteringHandler post = new HttpMethodFilteringHandler(POST, handler); LiveHttpRequest request = post("/some-uri").build(); post.handle(request, mock(HttpInterceptor.Context.class)); verify(handler).handle(eq(request), any(HttpInterceptor.Context.class)); }
@Override public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) { if (!method.equals(request.method())) { return Eventual.of( HttpResponse.response(METHOD_NOT_ALLOWED) .body(errorBody, StandardCharsets.UTF_8) .build() .stream() ); } return httpHandler.handle(request, context); } }
@Test public void exposesNameAndStatusViaAdminInterface() throws ExecutionException, InterruptedException { DerivedStyxService service = new DerivedStyxService("derived-service", new CompletableFuture<>()); HttpResponse response = Mono.from(service.adminInterfaceHandlers().get("status").handle(get, MOCK_CONTEXT) .flatMap(r -> r.aggregate(1024))).block(); assertThat(response.bodyAs(UTF_8), is("{ name: \"derived-service\" status: \"CREATED\" }")); }
@Override public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) { try { return resolveFile(request.path()) .map(ResolvedFile::new) .map(resolvedFile -> HttpResponse.response() .addHeader(CONTENT_TYPE, resolvedFile.mediaType) .body(resolvedFile.content, UTF_8) .build() .stream()) .map(Eventual::of) .orElseGet(() -> NOT_FOUND_HANDLER.handle(request, context)); } catch (IOException e) { return Eventual.of(HttpResponse.response(INTERNAL_SERVER_ERROR).build().stream()); } }
@Override public Eventual<LiveHttpResponse> proceed(LiveHttpRequest request) { requestTracker.trackRequest(request); if (index < interceptors.size()) { HttpInterceptor.Chain chain = new HttpInterceptorChain(this, index + 1); HttpInterceptor interceptor = interceptors.get(index); try { return interceptor.intercept(request, chain); } catch (Throwable e) { return Eventual.error(e); } } requestTracker.markRequestAsSent(request); return new Eventual<>(toPublisher(toObservable(client.handle(request, this.context)) .compose(StandardHttpPipeline::sendErrorOnDoubleSubscription))); } }
private Publisher<LiveHttpResponse> sendRequest(LiveHttpRequest request, List<RemoteHost> previousOrigins, int attempt) { if (attempt >= MAX_RETRY_ATTEMPTS) { return Flux.error(new NoAvailableHostsException(this.id)); } Optional<RemoteHost> remoteHost = selectOrigin(request); if (remoteHost.isPresent()) { RemoteHost host = remoteHost.get(); List<RemoteHost> newPreviousOrigins = newArrayList(previousOrigins); newPreviousOrigins.add(remoteHost.get()); return ResponseEventListener.from(host.hostClient().handle(request, HttpInterceptorContext.create()) .map(response -> addStickySessionIdentifier(response, host.origin()))) .whenResponseError(cause -> logError(request, cause)) .whenCancelled(() -> originStatsFactory.originStats(host.origin()).requestCancelled()) .apply() .doOnNext(this::recordErrorStatusMetrics) .map(response -> removeUnexpectedResponseBody(request, response)) .map(this::removeRedundantContentLengthHeader) .onErrorResume(cause -> { RetryPolicyContext retryContext = new RetryPolicyContext(this.id, attempt + 1, cause, request, previousOrigins); return retry(request, retryContext, newPreviousOrigins, attempt + 1, cause); }) .map(response -> addOriginId(host.id(), response)); } else { RetryPolicyContext retryContext = new RetryPolicyContext(this.id, attempt + 1, null, request, previousOrigins); return retry(request, retryContext, previousOrigins, attempt + 1, new NoAvailableHostsException(this.id)); } }
Observable<LiveHttpResponse> responseObservable = toObservable(httpPipeline.handle(v11Request, newInterceptorContext(ctx))); subscription = responseObservable .subscribe(new Subscriber<LiveHttpResponse>() {