Migrate some logic from generated code into the runtime library

.palantir/revapi.yml

@@ -0,0 +1,15 @@
+versionOverrides: {}
+acceptedBreaks:
+  "0.12.1":
+    com.palantir.dialogue:dialogue-apache-hc4-client: []
+    com.palantir.dialogue:dialogue-blocking-channels: []
+    com.palantir.dialogue:dialogue-core: []
+    com.palantir.dialogue:dialogue-httpurlconnection-client: []
+    com.palantir.dialogue:dialogue-java-client: []
+    com.palantir.dialogue:dialogue-okhttp-client: []
+    com.palantir.dialogue:dialogue-serde: []
+    com.palantir.dialogue:dialogue-target:
+    - code: "java.method.addedToInterface"
+      old: null
+      new: "method com.palantir.dialogue.Clients com.palantir.dialogue.ConjureRuntime::clients()"
+      justification: "alpha software, runtime not meant for extension"

changelog/@unreleased/pr-475.v2.yml

@@ -0,0 +1,5 @@
+type: improvement
+improvement:
+  description: Migrate some logic from generated code into the runtime library
+  links:
+  - https://github.com/palantir/dialogue/pull/475

dialogue-example/src/main/java/com/palantir/dialogue/example/SampleServiceClient.java

@@ -16,19 +16,15 @@
 
 package com.palantir.dialogue.example;
 
-import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.MoreExecutors;
 import com.palantir.dialogue.Channel;
 import com.palantir.dialogue.ConjureRuntime;
 import com.palantir.dialogue.Deserializer;
 import com.palantir.dialogue.Endpoint;
 import com.palantir.dialogue.HttpMethod;
 import com.palantir.dialogue.PathTemplate;
 import com.palantir.dialogue.PlainSerDe;
-import com.palantir.dialogue.RemoteExceptions;
 import com.palantir.dialogue.Request;
-import com.palantir.dialogue.Response;
 import com.palantir.dialogue.Serializer;
 import com.palantir.dialogue.TypeMarker;
 import com.palantir.dialogue.UrlBuilder;
@@ -138,25 +134,14 @@ public SampleObject objectToObject(
                         .putAllQueryParams("queryKey", plainSerDe.serializeRidList(query))
                         .body(sampleObjectToSampleObjectSerializer.serialize(body))
                         .build();
-
-                ListenableFuture<Response> call = channel.execute(STRING_TO_STRING, request);
-                ListenableFuture<SampleObject> response = Futures.transform(
-                        call,
-                        r -> sampleObjectToSampleObjectDeserializer.deserialize(r),
-                        MoreExecutors.directExecutor());
-
-                return RemoteExceptions.getUnchecked(response);
+                return runtime.clients()
+                        .blocking(channel, STRING_TO_STRING, request, sampleObjectToSampleObjectDeserializer);
             }
 
             @Override
             public void voidToVoid() {
                 Request request = Request.builder().build();
-
-                ListenableFuture<Response> call = channel.execute(VOID_TO_VOID, request);
-                ListenableFuture<Void> response = Futures.transform(
-                        call, r -> voidToVoidDeserializer.deserialize(r), MoreExecutors.directExecutor());
-
-                RemoteExceptions.getUnchecked(response);
+                runtime.clients().blocking(channel, VOID_TO_VOID, request, voidToVoidDeserializer);
             }
         };
     }
@@ -188,21 +173,14 @@ public ListenableFuture<SampleObject> stringToString(
                         .putAllQueryParams("queryKey", plainSerDe.serializeRidList(query))
                         .body(sampleObjectToSampleObjectSerializer.serialize(body))
                         .build();
-
-                ListenableFuture<Response> call = channel.execute(STRING_TO_STRING, request);
-                return Futures.transform(
-                        call,
-                        response -> sampleObjectToSampleObjectDeserializer.deserialize(response),
-                        MoreExecutors.directExecutor());
+                return runtime.clients()
+                        .call(channel, STRING_TO_STRING, request, sampleObjectToSampleObjectDeserializer);
             }
 
             @Override
             public ListenableFuture<Void> voidToVoid() {
                 Request request = Request.builder().build();
-
-                ListenableFuture<Response> call = channel.execute(VOID_TO_VOID, request);
-                return Futures.transform(
-                        call, response -> voidToVoidDeserializer.deserialize(response), MoreExecutors.directExecutor());
+                return runtime.clients().call(channel, VOID_TO_VOID, request, voidToVoidDeserializer);
             }
         };
     }

dialogue-serde/src/main/java/com/palantir/conjure/java/dialogue/serde/DefaultClients.java

@@ -0,0 +1,45 @@
+/*
+ * (c) Copyright 2020 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.conjure.java.dialogue.serde;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.palantir.dialogue.Channel;
+import com.palantir.dialogue.Clients;
+import com.palantir.dialogue.Deserializer;
+import com.palantir.dialogue.Endpoint;
+import com.palantir.dialogue.RemoteExceptions;
+import com.palantir.dialogue.Request;
+
+/** Package private internal API. */
+enum DefaultClients implements Clients {
+    INSTANCE;
+
+    @Override
+    public <T> ListenableFuture<T> call(
+            Channel channel, Endpoint endpoint, Request request, Deserializer<T> deserializer) {
+        return Futures.transform(
+                channel.execute(endpoint, request), deserializer::deserialize, MoreExecutors.directExecutor());
+    }
+
+    @Override
+    public <T> T blocking(Channel channel, Endpoint endpoint, Request request, Deserializer<T> deserializer) {
+        ListenableFuture<T> call = call(channel, endpoint, request, deserializer);
+        return RemoteExceptions.getUnchecked(call);
+    }
+}

dialogue-serde/src/main/java/com/palantir/conjure/java/dialogue/serde/DefaultConjureRuntime.java

@@ -19,6 +19,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.palantir.dialogue.BodySerDe;
+import com.palantir.dialogue.Clients;
 import com.palantir.dialogue.ConjureRuntime;
 import com.palantir.dialogue.PlainSerDe;
 import com.palantir.logsafe.Preconditions;
@@ -52,6 +53,11 @@ public PlainSerDe plainSerDe() {
         return ConjurePlainSerDe.INSTANCE;
     }
 
+    @Override
+    public Clients clients() {
+        return DefaultClients.INSTANCE;
+    }
+
     public static final class Builder {
 
         private final List<Encoding> encodings = new ArrayList<>();

dialogue-serde/src/test/java/com/palantir/conjure/java/dialogue/serde/DefaultClientsTest.java

@@ -0,0 +1,73 @@
+/*
+ * (c) Copyright 2020 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.conjure.java.dialogue.serde;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.palantir.dialogue.Channel;
+import com.palantir.dialogue.Deserializer;
+import com.palantir.dialogue.Endpoint;
+import com.palantir.dialogue.Request;
+import com.palantir.dialogue.Response;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public final class DefaultClientsTest {
+
+    @Mock
+    private Channel channel;
+
+    @Mock
+    private Endpoint endpoint;
+
+    @Mock
+    private Response response;
+
+    @Mock
+    private Deserializer<String> deserializer;
+
+    @Test
+    public void testAsync() throws ExecutionException, InterruptedException {
+        Request request = Request.builder().build();
+        when(deserializer.deserialize(eq(response))).thenReturn("value");
+        SettableFuture<Response> responseFuture = SettableFuture.create();
+        when(channel.execute(eq(endpoint), eq(request))).thenReturn(responseFuture);
+        ListenableFuture<String> result = DefaultClients.INSTANCE.call(channel, endpoint, request, deserializer);
+        assertThat(result).isNotDone();
+        responseFuture.set(response);
+        assertThat(result).isDone();
+        assertThat(result.get()).isEqualTo("value");
+    }
+
+    @Test
+    public void testBlocking() {
+        Request request = Request.builder().build();
+        when(deserializer.deserialize(eq(response))).thenReturn("value");
+        when(channel.execute(eq(endpoint), eq(request))).thenReturn(Futures.immediateFuture(response));
+        assertThat(DefaultClients.INSTANCE.blocking(channel, endpoint, request, deserializer))
+                .isEqualTo("value");
+    }
+}

dialogue-target/src/main/java/com/palantir/dialogue/Clients.java

@@ -0,0 +1,39 @@
+/*
+ * (c) Copyright 2020 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.dialogue;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+/**
+ * Provides functionality for generated code to make both blocking and asynchronous calls without
+ * duplicating logic.
+ */
+public interface Clients {
+
+    /**
+     * Makes a request to the specified {@link Endpoint} and deserializes the response using a provided deserializer.
+     */
+    <T> ListenableFuture<T> call(Channel channel, Endpoint endpoint, Request request, Deserializer<T> deserializer);
+
+    /**
+     * Semantics match {@link #call(Channel, Endpoint, Request, Deserializer)} but also blocks until
+     * the {@link ListenableFuture} has completed for blocking clients.
+     * This approach is used instead of using a separate method to block on a single future to simplify
+     * otherwise redundant generated code.
+     */
+    <T> T blocking(Channel channel, Endpoint endpoint, Request request, Deserializer<T> deserializer);
+}

dialogue-target/src/main/java/com/palantir/dialogue/ConjureRuntime.java

@@ -29,4 +29,7 @@ public interface ConjureRuntime {
 
     /** Provides the {@link PlainSerDe} used to parse request path, query, and header parameters. */
     PlainSerDe plainSerDe();
+
+    /** Provides the {@link Clients} used to facilitate making requests. */
+    Clients clients();
 }