Support behaviour changes based on URIs with a 'mesh-' prefix

dialogue-core/src/main/java/com/palantir/dialogue/core/ConcurrencyLimitedChannel.java

@@ -46,6 +46,10 @@ final class ConcurrencyLimitedChannel implements LimitedChannel {
     private final String channelNameForLogging;
 
     static LimitedChannel createForHost(Config cf, Channel channel, int uriIndex) {
+        if (cf.mesh() == MeshMode.USE_EXTERNAL_MESH) {
+            return new ChannelToLimitedChannelAdapter(channel);
+        }
+
         ClientConfiguration.ClientQoS clientQoS = cf.clientConf().clientQoS();
         switch (clientQoS) {
             case ENABLED:

dialogue-core/src/main/java/com/palantir/dialogue/core/Config.java

@@ -25,11 +25,13 @@
 import java.util.OptionalInt;
 import java.util.Random;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.stream.Collectors;
 import org.immutables.value.Value;
 
 /** Private class to centralize validation of params necessary to construct a dialogue channel. */
 @Value.Immutable
 interface Config {
+
     String channelName();
 
     ChannelFactory channelFactory();
@@ -40,11 +42,17 @@ interface Config {
     default ClientConfiguration clientConf() {
         return ClientConfiguration.builder()
                 .from(rawConfig())
+                .uris(rawConfig().uris().stream().map(MeshMode::stripMeshPrefix).collect(Collectors.toList()))
                 .taggedMetricRegistry(
                         VersionedTaggedMetricRegistry.create(rawConfig().taggedMetricRegistry()))
                 .build();
     }
 
+    @Value.Derived
+    default MeshMode mesh() {
+        return MeshMode.fromUris(rawConfig().uris(), SafeArg.of("channelName", channelName()));
+    }
+
     @Value.Default
     default Random random() {
         return SafeThreadLocalRandom.get();

dialogue-core/src/main/java/com/palantir/dialogue/core/DialogueChannel.java

@@ -134,7 +134,7 @@ public DialogueChannel build() {
                 Channel tracingChannel = new TraceEnrichingChannel(channel);
                 final int uriIndexForInstrumentation =
                         cf.overrideSingleHostIndex().orElse(uriIndex);
-                channel = cf.clientConf().clientQoS() == ClientQoS.ENABLED
+                channel = cf.clientConf().clientQoS() == ClientQoS.ENABLED && cf.mesh() != MeshMode.USE_EXTERNAL_MESH
                         ? new ChannelToEndpointChannel(endpoint -> {
                             LimitedChannel limited = ConcurrencyLimitedChannel.createForEndpoint(
                                     tracingChannel, cf.channelName(), uriIndexForInstrumentation, endpoint);
@@ -150,13 +150,13 @@ public DialogueChannel build() {
 
             EndpointChannelFactory channelFactory = endpoint -> {
                 EndpointChannel channel = new EndpointChannelAdapter(endpoint, queuedChannel);
-                channel = TracedChannel.requestAttempt(channel);
+                channel = TracedChannel.requestAttempt(cf, channel);
                 channel = RetryingChannel.create(cf, channel, endpoint);
                 channel = UserAgentEndpointChannel.create(
                         channel, endpoint, cf.clientConf().userAgent().get());
                 channel = DeprecationWarningChannel.create(cf, channel, endpoint);
                 channel = new ContentDecodingChannel(channel);
-                channel = TracedChannel.create(channel, endpoint);
+                channel = TracedChannel.create(cf, channel, endpoint);
                 channel = TimingEndpointChannel.create(cf, channel, endpoint);
                 channel = new InterruptionChannel(channel);
                 return new NeverThrowEndpointChannel(channel); // this must come last as a defensive backstop

dialogue-core/src/main/java/com/palantir/dialogue/core/MeshMode.java

@@ -0,0 +1,61 @@
+/*
+ * (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.core;
+
+import com.palantir.logsafe.Preconditions;
+import com.palantir.logsafe.SafeArg;
+import java.util.List;
+
+enum MeshMode {
+    DEFAULT_NO_MESH,
+    USE_EXTERNAL_MESH;
+
+    /**
+     * This prefix may reconfigure several aspects of the client to work better in a world where requests are routed
+     * through a service mesh like istio/envoy.
+     */
+    private static final String MESH_PREFIX = "mesh-";
+
+    static MeshMode fromUris(List<String> uris, SafeArg<String> channelName) {
+        long meshUris = uris.stream().filter(s -> s.startsWith(MESH_PREFIX)).count();
+        long normalUris = uris.stream().filter(s -> !s.startsWith(MESH_PREFIX)).count();
+
+        if (meshUris == 0) {
+            return MeshMode.DEFAULT_NO_MESH;
+        } else {
+            Preconditions.checkState(
+                    meshUris == 1,
+                    "Not expecting multiple 'mesh-' prefixed uris - please double-check the uris",
+                    SafeArg.of("meshUris", meshUris),
+                    SafeArg.of("normalUris", normalUris),
+                    channelName);
+            Preconditions.checkState(
+                    normalUris == 0,
+                    "When a 'mesh-' prefixed uri is present, there should not be any normal uris - please double "
+                            + "check the uris",
+                    SafeArg.of("meshUris", meshUris),
+                    SafeArg.of("normalUris", normalUris),
+                    channelName);
+
+            return MeshMode.USE_EXTERNAL_MESH;
+        }
+    }
+
+    public static String stripMeshPrefix(String input) {
+        return input.startsWith(MESH_PREFIX) ? input.substring(MESH_PREFIX.length()) : input;
+    }
+}

dialogue-core/src/main/java/com/palantir/dialogue/core/RetryingChannel.java

@@ -110,6 +110,14 @@ static EndpointChannel create(Config cf, EndpointChannel channel, Endpoint endpo
             return channel;
         }
 
+        if (cf.mesh() == MeshMode.USE_EXTERNAL_MESH) {
+            log.debug(
+                    "Disabling retrying channel due to MeshMode",
+                    SafeArg.of("channel", cf.channelName()),
+                    SafeArg.of("ignoredMaxNumRetries", clientConf.maxNumRetries()));
+            return channel;
+        }
+
         return new RetryingChannel(
                 channel,
                 endpoint,

dialogue-core/src/main/java/com/palantir/dialogue/core/TracedChannel.java

@@ -37,13 +37,18 @@ private TracedChannel(EndpointChannel delegate, String operationName) {
         this.operationNameInitial = operationName + " initial";
     }
 
-    static EndpointChannel create(EndpointChannel delegate, Endpoint endpoint) {
-        String operationName = "Dialogue: request " + endpoint.serviceName() + "#" + endpoint.endpointName();
+    static EndpointChannel create(Config cf, EndpointChannel delegate, Endpoint endpoint) {
+        String operationName =
+                "Dialogue: request " + endpoint.serviceName() + "#" + endpoint.endpointName() + meshSuffix(cf.mesh());
         return new TracedChannel(delegate, operationName);
     }
 
-    static EndpointChannel requestAttempt(EndpointChannel delegate) {
-        return new TracedChannel(delegate, "Dialogue-request-attempt");
+    static EndpointChannel requestAttempt(Config cf, EndpointChannel delegate) {
+        return new TracedChannel(delegate, "Dialogue-request-attempt" + meshSuffix(cf.mesh()));
+    }
+
+    private static String meshSuffix(MeshMode meshMode) {
+        return meshMode == MeshMode.USE_EXTERNAL_MESH ? " (Mesh)" : "";
     }
 
     @Override

dialogue-core/src/test/java/com/palantir/dialogue/core/MeshModeTest.java

@@ -0,0 +1,70 @@
+/*
+ * (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.core;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.palantir.logsafe.SafeArg;
+import com.palantir.logsafe.exceptions.SafeIllegalStateException;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+import org.junit.jupiter.api.Test;
+
+class MeshModeTest {
+
+    @Test
+    void normal_uris_are_not_mesh() {
+        MeshMode mode = fromUris("https://server.whatever", "http://server.another");
+        assertThat(mode).isEqualTo(MeshMode.DEFAULT_NO_MESH);
+    }
+
+    @Test
+    void single_prefix_triggers_mesh_mode() {
+        MeshMode mode = fromUris("mesh-https://server.whatever");
+        assertThat(mode).isEqualTo(MeshMode.USE_EXTERNAL_MESH);
+    }
+
+    @Test
+    void empty_uris_doesnt_break() {
+        MeshMode mode = fromUris();
+        assertThat(mode).isEqualTo(MeshMode.DEFAULT_NO_MESH);
+    }
+
+    @Test
+    void mixed_uris_breaks() {
+        assertThatThrownBy(() -> fromUris("https://server.whatever", "mesh-http://server.another"))
+                .isInstanceOf(SafeIllegalStateException.class)
+                .hasMessage(
+                        "When a 'mesh-' prefixed uri is present, there should not be any normal uris - please double "
+                                + "check the uris: "
+                                + "{meshUris=1, normalUris=1, channelName=channelName}");
+    }
+
+    @Test
+    void multiple_prefixes_breaks() {
+        assertThatThrownBy(() -> fromUris("mesh-https://server.whatever", "mesh-http://server.another"))
+                .isInstanceOf(SafeIllegalStateException.class)
+                .hasMessage("Not expecting multiple 'mesh-' prefixed uris - please double-check the uris: "
+                        + "{meshUris=2, normalUris=0, channelName=channelName}");
+    }
+
+    private MeshMode fromUris(String... uris) {
+        return MeshMode.fromUris(
+                Arrays.stream(uris).collect(Collectors.toList()), SafeArg.of("channelName", "channelName"));
+    }
+}