refactor DeadlineExpiredException to use nested subclass types

Author: Brian Laub

deadlines-api/src/main/java/com/palantir/deadlines/api/DeadlineExpiredException.java

@@ -18,41 +18,60 @@
 
 import com.palantir.logsafe.Arg;
 import com.palantir.logsafe.Safe;
-import com.palantir.logsafe.SafeArg;
 import com.palantir.logsafe.SafeLoggable;
 import java.util.List;
 
 /**
  * Indicates that a deadline has expired.
  */
-public final class DeadlineExpiredException extends RuntimeException implements SafeLoggable {
-    private static final String MESSAGE = "A deadline for completing work has expired.";
-    private final List<Arg<?>> args;
-    private final boolean internal;
-
-    /**
-     * Create a new DeadlineExpiredException.
-     *
-     * @param internal true if this is expiration was for an internally-sourced deadline (such as one assigned
-     * internally by a server), or false if it was for a externally-sourced deadline (such as one provided by a
-     * client in a request header)
-     */
-    public DeadlineExpiredException(boolean internal) {
-        this.args = List.of(SafeArg.of("internal", internal));
-        this.internal = internal;
+public abstract class DeadlineExpiredException extends RuntimeException {
+    private DeadlineExpiredException(String message) {
+        super(message);
     }
 
-    @Override
-    public @Safe String getLogMessage() {
-        return MESSAGE;
+    public static External external() {
+        return new External();
     }
 
-    @Override
-    public List<Arg<?>> getArgs() {
-        return args;
+    public static Internal internal() {
+        return new Internal();
     }
 
-    public boolean isInternal() {
-        return internal;
+    public static final class External extends DeadlineExpiredException implements SafeLoggable {
+        private static final String MESSAGE = "An externally provided deadline for completing work has expired.";
+        private static final List<Arg<?>> ARGS = List.of();
+
+        private External() {
+            super(MESSAGE);
+        }
+
+        @Override
+        public @Safe String getLogMessage() {
+            return MESSAGE;
+        }
+
+        @Override
+        public List<Arg<?>> getArgs() {
+            return ARGS;
+        }
+    }
+
+    public static final class Internal extends DeadlineExpiredException implements SafeLoggable {
+        private static final String MESSAGE = "An internal deadline for completing work has expired.";
+        private static final List<Arg<?>> ARGS = List.of();
+
+        private Internal() {
+            super(MESSAGE);
+        }
+
+        @Override
+        public @Safe String getLogMessage() {
+            return MESSAGE;
+        }
+
+        @Override
+        public List<Arg<?>> getArgs() {
+            return ARGS;
+        }
     }
 }

deadlines/src/main/java/com/palantir/deadlines/Deadlines.java

@@ -170,7 +170,10 @@ private static void checkExpiration(long deadline, boolean internal) {
             // expired
             Expired_Cause cause = internal ? Expired_Cause.INTERNAL : Expired_Cause.EXTERNAL;
             metrics.expired(cause).mark();
-            throw new DeadlineExpiredException(internal);
+            if (internal) {
+                throw DeadlineExpiredException.internal();
+            }
+            throw DeadlineExpiredException.external();
         }
     }
 

deadlines/src/test/java/com/palantir/deadlines/DeadlinesTest.java

@@ -190,11 +190,7 @@ public void test_encode_to_request_expiration_external_deadline() {
             Map<String, String> outbound = new HashMap<>();
             assertThatThrownBy(() ->
                             Deadlines.encodeToRequest(Duration.ofSeconds(10), outbound, DummyRequestEncoder.INSTANCE))
-                    .isInstanceOf(DeadlineExpiredException.class)
-                    .satisfies(t -> {
-                        DeadlineExpiredException exc = (DeadlineExpiredException) t;
-                        assertThat(exc.isInternal()).isFalse();
-                    });
+                    .isInstanceOf(DeadlineExpiredException.External.class);
 
             assertThat(externalMeter.getCount()).isGreaterThan(originalExternalValue);
             assertThat(internalMeter.getCount()).isEqualTo(originalInternalValue);
@@ -226,11 +222,7 @@ public void test_encode_to_request_expiration_internal_deadline() {
             Map<String, String> outbound = new HashMap<>();
             assertThatThrownBy(() ->
                             Deadlines.encodeToRequest(Duration.ofSeconds(10), outbound, DummyRequestEncoder.INSTANCE))
-                    .isInstanceOf(DeadlineExpiredException.class)
-                    .satisfies(t -> {
-                        DeadlineExpiredException exc = (DeadlineExpiredException) t;
-                        assertThat(exc.isInternal()).isTrue();
-                    });
+                    .isInstanceOf(DeadlineExpiredException.Internal.class);
 
             assertThat(internalMeter.getCount()).isGreaterThan(originalInternalValue);
             assertThat(externalMeter.getCount()).isEqualTo(originalExternalValue);