Clean up deprecated requester/client/filter API

[idelpivnitskiy]

Motivation:

#1956 removed requester/client methods that take
HttpExecutionStrategy. All deprecated API can be removed now.

Modifications:

• Remove deprecated request method from a requester;
• Remove deprecated reserveConnection method from a client;
• Remove NewToDeprecated utility;
• Migrate all existing filters and tests to the new filter API;
• Pass an HttpExecutionStrategy through request context;

Result:

No deprecated API on requester/client/filter API.

[idelpivnitskiy]

Depends on #1956, review only the last commit: 59dac1c

[Scottmitch]

can you clarify why we need .subscribeShareContext here? typically this is used as the last operator in a defer(() -> ... subscribeShareContext())

[idelpivnitskiy]

My understanding was that subscribeShareContext() is required for any async operator in order to share it. It looks like without subscribeShareContext(), users of aggregated API have a copy of the context when their filter processes a payload body instead of sharing a single context.

[Scottmitch]

yes subscribeShareContext will make it so when subscribe is done, the context map is not copied (same instance is used). Good catch, seems like this would impact operators transforming the response publisher (see below). Can you add some quick tests for this? IIRC @tkountis extracted out AbstractHttpServiceAsyncContextTest can we just use this from the blocking Client API to verify?

diff --git a/servicetalk-examples/http/helloworld/src/main/java/io/servicetalk/examples/http/helloworld/blocking/BlockingHelloWorldClient.java b/servicetalk-examples/http/helloworld/src/main/java/io/servicetalk/examples/http/helloworld/blocking/BlockingHelloWorldClient.java
index 1913a24a3..cb1eb0b59 100644
--- a/servicetalk-examples/http/helloworld/src/main/java/io/servicetalk/examples/http/helloworld/blocking/BlockingHelloWorldClient.java
+++ b/servicetalk-examples/http/helloworld/src/main/java/io/servicetalk/examples/http/helloworld/blocking/BlockingHelloWorldClient.java
@@ -15,8 +15,16 @@
  */
 package io.servicetalk.examples.http.helloworld.blocking;
 
+import io.servicetalk.concurrent.api.AsyncContext;
+import io.servicetalk.concurrent.api.Single;
 import io.servicetalk.http.api.BlockingHttpClient;
+import io.servicetalk.http.api.FilterableStreamingHttpClient;
 import io.servicetalk.http.api.HttpResponse;
+import io.servicetalk.http.api.StreamingHttpClientFilter;
+import io.servicetalk.http.api.StreamingHttpClientFilterFactory;
+import io.servicetalk.http.api.StreamingHttpRequest;
+import io.servicetalk.http.api.StreamingHttpRequester;
+import io.servicetalk.http.api.StreamingHttpResponse;
 import io.servicetalk.http.netty.HttpClients;
 
 import static io.servicetalk.http.api.HttpSerializers.textSerializerUtf8;
@@ -24,7 +32,26 @@ import static io.servicetalk.http.api.HttpSerializers.textSerializerUtf8;
 public final class BlockingHelloWorldClient {
 
     public static void main(String[] args) throws Exception {
-        try (BlockingHttpClient client = HttpClients.forSingleAddress("localhost", 8080).buildBlocking()) {
+        try (BlockingHttpClient client = HttpClients.forSingleAddress("localhost", 8080)
+                .appendClientFilter(client1 -> new StreamingHttpClientFilter(client1) {
+                    @Override
+                    protected Single<StreamingHttpResponse> request(final StreamingHttpRequester delegate,
+                                                                    final StreamingHttpRequest request) {
+                        System.err.println("1: " + AsyncContext.context());
+                        return delegate.request(request)
+                                .flatMap(response -> {
+                                    System.err.println("2: " + AsyncContext.context());
+                                    return Single.succeeded(response.transformPayloadBody(body -> {
+                                        System.err.println("3: " + AsyncContext.context());
+                                        return body.map(buf -> {
+                                            System.err.println("4: " + AsyncContext.context());
+                                            return buf;
+                                        });
+                                    }));
+                                });
+                    }
+                })
+                .buildBlocking()) {
             HttpResponse response = client.request(client.get("/sayHello"));
             System.out.println(response.toString((name, value) -> value));
             System.out.println(response.payloadBody(textSerializerUtf8()));

with subscribeShareContext:

1: CopyOnWriteContextMap@56e8b606:{}
2: CopyOnWriteContextMap@56e8b606:{}
3: CopyOnWriteContextMap@56e8b606:{}
4: CopyOnWriteContextMap@56e8b606:{}

without subscribeShareContext (note different instance in 4):

1: CopyOnWriteContextMap@56e8b606:{}
2: CopyOnWriteContextMap@56e8b606:{}
3: CopyOnWriteContextMap@56e8b606:{}
4: CopyOnWriteContextMap@1223cd05:{}

[idelpivnitskiy]

I've tried to adopt AbstractHttpServiceAsyncContextTest for BlockingHttpService, but it doesn't cover a use-case of a context change between aggregating a request payload body and further processing. I've opened #1967 to track it.