Examples with Single io.servicetalk.concurrent.api.Single used on opensource projects

Example 36 with Single

use of io.servicetalk.concurrent.api.Single in project servicetalk by apple.

the class StreamingHttpServiceToOffloadedStreamingHttpService method handle.

@Override
public Single<StreamingHttpResponse> handle(final HttpServiceContext ctx, StreamingHttpRequest request, final StreamingHttpResponseFactory responseFactory) {
    // We compute the difference between the ExecutionStrategy from the current ExecutionContext and
    // this ExecutionStrategy to understand if we need to offload more than we already offloaded:
    final HttpExecutionStrategy additionalOffloads = ctx.executionContext().executionStrategy().missing(strategy);
    Executor useExecutor = null != executor ? executor : ctx.executionContext().executor();
    // The service should see this ExecutionStrategy and Executor inside the ExecutionContext:
    final HttpServiceContext wrappedCtx = new ExecutionContextOverridingServiceContext(ctx, strategy, useExecutor);
    if (!additionalOffloads.isRequestResponseOffloaded()) {
        // No additional offloading needed.
        return delegate.handle(wrappedCtx, request, responseFactory);
    } else {
        if (additionalOffloads.isDataReceiveOffloaded()) {
            request = request.transformMessageBody(p -> p.publishOn(useExecutor, shouldOffload));
        }
        final Single<StreamingHttpResponse> resp;
        if (additionalOffloads.isMetadataReceiveOffloaded() && shouldOffload.getAsBoolean()) {
            final StreamingHttpRequest r = request;
            resp = useExecutor.submit(() -> delegate.handle(wrappedCtx, r, responseFactory).shareContextOnSubscribe()).flatMap(identity());
        } else {
            resp = delegate.handle(wrappedCtx, request, responseFactory);
        }
        return additionalOffloads.isSendOffloaded() ? // contract and hence have to offload both meta and data separately.
        resp.map(r -> r.transformMessageBody(p -> p.subscribeOn(useExecutor, shouldOffload))).subscribeOn(useExecutor, shouldOffload) : resp;
    }
}

Example 37 with Single

use of io.servicetalk.concurrent.api.Single in project servicetalk by apple.

the class ContentLengthAndTrailersTest method setUp.

private void setUp(HttpProtocol protocol, String content) {
    this.protocol = protocol;
    this.content = content;
    protocol(protocol.config);
    serviceFilterFactory(service -> new StreamingHttpServiceFilter(service) {

        @Override
        public Single<StreamingHttpResponse> handle(final HttpServiceContext ctx, final StreamingHttpRequest request, final StreamingHttpResponseFactory responseFactory) {
            // Use transform to simulate access to request trailers
            return delegate().handle(ctx, request.transform(new StatelessTrailersTransformer<>()), responseFactory).map(response -> {
                final HttpHeaders headers = request.headers();
                if (headers.contains(CONTENT_LENGTH)) {
                    response.setHeader(CLIENT_CONTENT_LENGTH, mergeValues(headers.values(CONTENT_LENGTH)));
                }
                if (headers.contains(TRANSFER_ENCODING)) {
                    response.setHeader(CLIENT_TRANSFER_ENCODING, mergeValues(headers.values(TRANSFER_ENCODING)));
                }
                return response;
            });
        }
    });
    setUp(CACHED, CACHED_SERVER);
}

Example 38 with Single

use of io.servicetalk.concurrent.api.Single in project servicetalk by apple.

the class ConnectionFactoryOffloadingTest method testFactoryOffloading.

@ParameterizedTest(name = "offload={0} httpStrategy={1}")
@MethodSource("testCases")
void testFactoryOffloading(boolean offload, HttpExecutionStrategy httpStrategy) throws Exception {
    AtomicReference<Thread> factoryThread = new AtomicReference<>();
    Thread appThread = Thread.currentThread();
    try (ServerContext server = HttpServers.forPort(0).listenAndAwait(this::helloWorld)) {
        SocketAddress serverAddress = server.listenAddress();
        ConnectionFactoryFilter<SocketAddress, FilterableStreamingHttpConnection> factory = ConnectionFactoryFilter.withStrategy(original -> new ConnectionFactory<SocketAddress, FilterableStreamingHttpConnection>() {

            private final ListenableAsyncCloseable close = emptyAsyncCloseable();

            @Override
            public Single<FilterableStreamingHttpConnection> newConnection(final SocketAddress socketAddress, @Nullable final ContextMap context, @Nullable final TransportObserver observer) {
                factoryThread.set(Thread.currentThread());
                return original.newConnection(socketAddress, context, observer);
            }

            @Override
            public Completable onClose() {
                return close.onClose();
            }

            @Override
            public Completable closeAsync() {
                return close.closeAsync();
            }

            @Override
            public Completable closeAsyncGracefully() {
                return close.closeAsyncGracefully();
            }
        }, new ConnectAndHttpExecutionStrategy(offload ? ConnectExecutionStrategy.offloadAll() : ConnectExecutionStrategy.offloadNone(), httpStrategy));
        try (HttpClient client = HttpClients.forResolvedAddress(serverAddress).appendConnectionFactoryFilter(factory).build()) {
            assertThat(client.executionContext().executionStrategy().missing(httpStrategy), is(HttpExecutionStrategies.offloadNone()));
            Single<HttpResponse> single = client.request(client.get("/sayHello"));
            HttpResponse response = single.toFuture().get();
            assertThat("unexpected status", response.status(), is(HttpResponseStatus.OK));
        }
    }
    assertTrue((offload && !IoThreadFactory.IoThread.isIoThread(factoryThread.get())) || (!offload && factoryThread.get() == appThread), "incorrect offloading, offload=" + offload + " thread=" + factoryThread.get());
}

Example 39 with Single

use of io.servicetalk.concurrent.api.Single in project servicetalk by apple.

the class ConsumeRequestPayloadOnResponsePathTest method test.

private void test(final BiFunction<Single<StreamingHttpResponse>, StreamingHttpRequest, Single<StreamingHttpResponse>> consumeRequestPayload) throws Exception {
    try (ServerContext serverContext = HttpServers.forAddress(localAddress(0)).appendServiceFilter(service -> new StreamingHttpServiceFilter(service) {

        @Override
        public Single<StreamingHttpResponse> handle(final HttpServiceContext ctx, final StreamingHttpRequest request, final StreamingHttpResponseFactory responseFactory) {
            return consumeRequestPayload.apply(delegate().handle(ctx, request, responseFactory), request);
        }
    }).listenStreamingAndAwait((ctx, request, responseFactory) -> {
        final StreamingHttpResponse response = responseFactory.ok().addHeader(TRAILER, X_TOTAL_LENGTH).payloadBody(from("Response\n", "Payload\n", "Body\n"), appSerializerUtf8FixLen()).transform(new TrailersTransformer<AtomicInteger, Buffer>() {

            @Override
            public AtomicInteger newState() {
                return new AtomicInteger();
            }

            @Override
            public Buffer accept(final AtomicInteger total, final Buffer chunk) {
                total.addAndGet(chunk.readableBytes());
                return chunk;
            }

            @Override
            public HttpHeaders payloadComplete(final AtomicInteger total, final HttpHeaders trailers) {
                trailers.add(X_TOTAL_LENGTH, String.valueOf(total.get()));
                return trailers;
            }

            @Override
            public HttpHeaders catchPayloadFailure(final AtomicInteger __, final Throwable ___, final HttpHeaders trailers) {
                return trailers;
            }
        });
        return succeeded(response);
    })) {
        HttpResponse response;
        try (BlockingHttpClient client = HttpClients.forSingleAddress(AddressUtils.serverHostAndPort(serverContext)).buildBlocking()) {
            response = client.request(client.post("/").payloadBody(EXPECTED_REQUEST_PAYLOAD, textSerializerUtf8()));
            serverLatch.await();
        }
        assertThat(response.status(), is(OK));
        assertThat("Request payload body might be consumed by someone else", errorRef.get(), is(nullValue()));
        assertThat(receivedPayload.toString(), is(EXPECTED_REQUEST_PAYLOAD));
        assertThat(response.headers().contains(TRAILER, X_TOTAL_LENGTH), is(true));
        assertThat(response.trailers().contains(X_TOTAL_LENGTH), is(true));
        CharSequence trailerLength = response.trailers().get(X_TOTAL_LENGTH);
        assertNotNull(trailerLength);
        assertThat("Unexpected response payload: '" + response.payloadBody().toString(UTF_8) + "'", trailerLength.toString(), is(Integer.toString(response.payloadBody().readableBytes())));
    }
}

Example 40 with Single

use of io.servicetalk.concurrent.api.Single in project servicetalk by apple.

the class AbstractEchoServerBasedHttpRequesterTest method makeRequestValidateResponseAndClose.

static void makeRequestValidateResponseAndClose(StreamingHttpRequester requester) throws ExecutionException, InterruptedException {
    try {
        StreamingHttpRequest request = requester.get("/request?foo=bar&foo=baz").payloadBody(from(DEFAULT_ALLOCATOR.fromAscii("Testing123")));
        request.headers().set(HOST, "mock.servicetalk.io");
        StreamingHttpResponse resp = awaitIndefinitelyNonNull(requester.request(request).retryWhen(retryWithExponentialBackoffFullJitter(10, t -> true, ofMillis(100), ofDays(10), CTX.executor())));
        assertThat(resp.status(), equalTo(OK));
        Single<String> respBody = resp.payloadBody().collect(StringBuilder::new, (sb, buf) -> {
            sb.append(buf.toString(UTF_8));
            return sb;
        }).map(StringBuilder::toString);
        HttpHeaders headers = resp.headers();
        assertThat(headers.get("test-req-method"), hasToString(GET.toString()));
        assertThat(headers.get("test-req-target"), hasToString("/request?foo=bar&foo=baz"));
        assertThat(headers.get("test-req-header-host"), hasToString("mock.servicetalk.io"));
        assertThat(headers.get("test-req-header-transfer-encoding"), equalTo(CHUNKED));
        assertThat(respBody.toFuture().get(), equalTo("Testing123"));
    } finally {
        requester.closeAsync().toFuture().get();
    }
}