Make GraffitiManagementException a RuntimeException

Author: courtneyeh

validator/api/src/main/java/tech/pegasys/teku/validator/api/GraffitiManagementException.java

@@ -13,7 +13,7 @@
 
 package tech.pegasys.teku.validator.api;
 
-public class GraffitiManagementException extends Exception {
+public class GraffitiManagementException extends RuntimeException {
 
   public GraffitiManagementException(final String message) {
     super(message);

validator/api/src/main/java/tech/pegasys/teku/validator/api/UpdatableGraffitiProvider.java

@@ -14,16 +14,15 @@
 package tech.pegasys.teku.validator.api;
 
 import java.util.Optional;
+import java.util.function.Supplier;
 import org.apache.tuweni.bytes.Bytes32;
-import tech.pegasys.teku.infrastructure.async.ExceptionThrowingSupplier;
 
 public class UpdatableGraffitiProvider implements GraffitiProvider {
-  private final ExceptionThrowingSupplier<Optional<Bytes32>> storageProvider;
+  private final Supplier<Optional<Bytes32>> storageProvider;
   private final GraffitiProvider defaultProvider;
 
   public UpdatableGraffitiProvider(
-      final ExceptionThrowingSupplier<Optional<Bytes32>> storageProvider,
-      final GraffitiProvider defaultProvider) {
+      final Supplier<Optional<Bytes32>> storageProvider, final GraffitiProvider defaultProvider) {
     this.storageProvider = storageProvider;
     this.defaultProvider = defaultProvider;
   }
@@ -36,12 +35,15 @@ public Optional<Bytes32> get() {
   private Optional<Bytes32> getFromStorage() {
     try {
       return storageProvider.get();
-    } catch (Throwable e) {
+    } catch (Exception e) {
       return Optional.empty();
     }
   }
 
-  public Optional<Bytes32> getUnsafe() throws Throwable {
+  /**
+   * @return graffiti without checking for thrown Exceptions.
+   */
+  public Optional<Bytes32> getUnsafe() {
     return storageProvider.get().or(defaultProvider::get);
   }
 }

validator/api/src/test/java/tech/pegasys/teku/validator/api/UpdatableGraffitiProviderTest.java

@@ -15,13 +15,11 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
 import java.util.Optional;
+import java.util.function.Supplier;
 import org.apache.tuweni.bytes.Bytes32;
 import org.junit.jupiter.api.Test;
-import tech.pegasys.teku.infrastructure.async.ExceptionThrowingSupplier;
 import tech.pegasys.teku.spec.TestSpecFactory;
 import tech.pegasys.teku.spec.util.DataStructureUtil;
 
@@ -59,49 +57,49 @@ void get_shouldBeEmptyWhenBothEmpty() {
   }
 
   @Test
-  @SuppressWarnings("unchecked")
-  public void get_shouldDelegateToDefaultProviderWhenStorageProviderFails() throws Throwable {
-    final ExceptionThrowingSupplier<Optional<Bytes32>> storageProvider =
-        mock(ExceptionThrowingSupplier.class);
-    when(storageProvider.get()).thenThrow(new RuntimeException("Error"));
+  public void get_shouldDelegateToDefaultProviderWhenStorageProviderFails() {
+    final Supplier<Optional<Bytes32>> storageProvider =
+        () -> {
+          throw new RuntimeException("Error");
+        };
 
     provider = new UpdatableGraffitiProvider(storageProvider, () -> Optional.of(defaultGraffiti));
     assertThat(provider.get()).hasValue(defaultGraffiti);
   }
 
   @Test
-  void getWithThrowable_shouldGetStorageGraffitiWhenAvailable() throws Throwable {
+  void getWithThrowable_shouldGetStorageGraffitiWhenAvailable() {
     provider = new UpdatableGraffitiProvider(() -> Optional.of(storageGraffiti), Optional::empty);
     assertThat(provider.getUnsafe()).hasValue(storageGraffiti);
   }
 
   @Test
-  void getWithThrowable_shouldGetStorageGraffitiWhenBothAvailable() throws Throwable {
+  void getWithThrowable_shouldGetStorageGraffitiWhenBothAvailable() {
     provider =
         new UpdatableGraffitiProvider(
             () -> Optional.of(storageGraffiti), () -> Optional.of(defaultGraffiti));
     assertThat(provider.getUnsafe()).hasValue(storageGraffiti);
   }
 
   @Test
-  void getWithThrowable_shouldGetDefaultGraffitiWhenStorageEmpty() throws Throwable {
+  void getWithThrowable_shouldGetDefaultGraffitiWhenStorageEmpty() {
     provider = new UpdatableGraffitiProvider(Optional::empty, () -> Optional.of(defaultGraffiti));
     assertThat(provider.getUnsafe()).hasValue(defaultGraffiti);
   }
 
   @Test
-  void getWithThrowable_shouldBeEmptyWhenBothEmpty() throws Throwable {
+  void getWithThrowable_shouldBeEmptyWhenBothEmpty() {
     provider = new UpdatableGraffitiProvider(Optional::empty, Optional::empty);
     assertThat(provider.getUnsafe()).isEmpty();
   }
 
   @Test
-  @SuppressWarnings("unchecked")
-  public void getWithThrowable_shouldThrowExceptionWhenStorageProviderFails() throws Throwable {
+  public void getWithThrowable_shouldThrowExceptionWhenStorageProviderFails() {
     final RuntimeException exception = new RuntimeException("Error");
-    final ExceptionThrowingSupplier<Optional<Bytes32>> storageProvider =
-        mock(ExceptionThrowingSupplier.class);
-    when(storageProvider.get()).thenThrow(exception);
+    final Supplier<Optional<Bytes32>> storageProvider =
+        () -> {
+          throw exception;
+        };
 
     provider = new UpdatableGraffitiProvider(storageProvider, () -> Optional.of(defaultGraffiti));
     assertThatThrownBy(() -> provider.getUnsafe()).isEqualTo(exception);

validator/client/src/main/java/tech/pegasys/teku/validator/client/ValidatorClientService.java

@@ -23,14 +23,14 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.Random;
+import java.util.function.Function;
 import java.util.function.Supplier;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.tuweni.bytes.Bytes32;
 import org.hyperledger.besu.plugin.services.MetricsSystem;
 import tech.pegasys.teku.bls.BLSPublicKey;
 import tech.pegasys.teku.infrastructure.async.AsyncRunner;
-import tech.pegasys.teku.infrastructure.async.ExceptionThrowingFunction;
 import tech.pegasys.teku.infrastructure.async.SafeFuture;
 import tech.pegasys.teku.infrastructure.events.EventChannels;
 import tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil;
@@ -163,14 +163,8 @@ public static ValidatorClientService create(
             validatorApiConfig.isRestApiEnabled()
                 ? new GraffitiManager(services.getDataDirLayout())
                 : null);
-    final ExceptionThrowingFunction<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider =
-        (publicKey) -> {
-          if (graffitiManager.isPresent()) {
-            final GraffitiManager manager = graffitiManager.get();
-            return manager.getGraffiti(publicKey);
-          }
-          return Optional.empty();
-        };
+    final Function<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider =
+        (publicKey) -> graffitiManager.flatMap(manager -> manager.getGraffiti(publicKey));
 
     final ValidatorLoader validatorLoader =
         createValidatorLoader(services, config, asyncRunner, updatableGraffitiProvider);
@@ -414,7 +408,7 @@ private static ValidatorLoader createValidatorLoader(
       final ServiceConfig services,
       final ValidatorClientConfiguration config,
       final AsyncRunner asyncRunner,
-      final ExceptionThrowingFunction<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider) {
+      final Function<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider) {
     final Path slashingProtectionPath = getSlashingProtectionPath(services.getDataDirLayout());
     final SlashingProtector slashingProtector =
         config.getValidatorConfig().isLocalSlashingProtectionSynchronizedModeEnabled()

validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/MultithreadedValidatorLoader.java

@@ -24,9 +24,9 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
 import org.apache.tuweni.bytes.Bytes32;
 import tech.pegasys.teku.bls.BLSPublicKey;
-import tech.pegasys.teku.infrastructure.async.ExceptionThrowingFunction;
 import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout;
 import tech.pegasys.teku.spec.signatures.DeletableSigner;
 import tech.pegasys.teku.validator.api.GraffitiProvider;
@@ -49,7 +49,7 @@ public static void loadValidators(
       final OwnedValidators ownedValidators,
       final Map<BLSPublicKey, ValidatorProvider> providers,
       final GraffitiProvider defaultGraffitiProvider,
-      final ExceptionThrowingFunction<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider,
+      final Function<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider,
       final Optional<DataDirLayout> maybeDataDirLayout) {
     final int totalValidatorCount = providers.size();
     STATUS_LOG.loadingValidators(totalValidatorCount);

validator/client/src/main/java/tech/pegasys/teku/validator/client/loader/ValidatorLoader.java

@@ -20,6 +20,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 import java.util.function.Supplier;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -30,7 +31,6 @@
 import tech.pegasys.teku.bls.keystore.model.KeyStoreData;
 import tech.pegasys.teku.data.SlashingProtectionImporter;
 import tech.pegasys.teku.infrastructure.async.AsyncRunner;
-import tech.pegasys.teku.infrastructure.async.ExceptionThrowingFunction;
 import tech.pegasys.teku.service.serviceutils.layout.DataDirLayout;
 import tech.pegasys.teku.spec.Spec;
 import tech.pegasys.teku.spec.signatures.DeletableSigner;
@@ -55,8 +55,7 @@ public class ValidatorLoader {
   private final Optional<ValidatorSource> mutableExternalValidatorSource;
   private final OwnedValidators ownedValidators = new OwnedValidators();
   private final GraffitiProvider defaultGraffitiProvider;
-  private final ExceptionThrowingFunction<BLSPublicKey, Optional<Bytes32>>
-      updatableGraffitiProvider;
+  private final Function<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider;
   private final Optional<DataDirLayout> maybeDataDirLayout;
   private final SlashingProtectionLogger slashingProtectionLogger;
 
@@ -65,7 +64,7 @@ private ValidatorLoader(
       final Optional<ValidatorSource> mutableLocalValidatorSource,
       final Optional<ValidatorSource> mutableExternalValidatorSource,
       final GraffitiProvider defaultGraffitiProvider,
-      final ExceptionThrowingFunction<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider,
+      final Function<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider,
       final Optional<DataDirLayout> maybeDataDirLayout,
       final SlashingProtectionLogger slashingProtectionLogger) {
     this.validatorSources = validatorSources;
@@ -242,7 +241,7 @@ public static ValidatorLoader create(
       final AsyncRunner asyncRunner,
       final MetricsSystem metricsSystem,
       final Optional<DataDirLayout> maybeMutableDir,
-      final ExceptionThrowingFunction<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider) {
+      final Function<BLSPublicKey, Optional<Bytes32>> updatableGraffitiProvider) {
     final ValidatorSourceFactory validatorSources =
         new ValidatorSourceFactory(
             spec,

validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffiti.java

@@ -34,6 +34,7 @@
 import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint;
 import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest;
 import tech.pegasys.teku.validator.api.Bytes32Parser;
+import tech.pegasys.teku.validator.api.GraffitiManagementException;
 import tech.pegasys.teku.validator.api.UpdatableGraffitiProvider;
 import tech.pegasys.teku.validator.client.KeyManager;
 import tech.pegasys.teku.validator.client.Validator;
@@ -94,7 +95,7 @@ public void handleRequest(final RestApiRequest request) throws JsonProcessingExc
       final UpdatableGraffitiProvider provider =
           (UpdatableGraffitiProvider) maybeValidator.get().getGraffitiProvider();
       request.respondOk(new GraffitiResponse(publicKey, provider.getUnsafe()));
-    } catch (Throwable e) {
+    } catch (GraffitiManagementException e) {
       request.respondError(SC_INTERNAL_SERVER_ERROR, e.getMessage());
     }
   }

validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/DeleteGraffitiTest.java

@@ -60,7 +60,7 @@ class DeleteGraffitiTest {
           .build();
 
   @Test
-  void shouldSuccessfullyDeleteGraffiti() throws IOException, GraffitiManagementException {
+  void shouldSuccessfullyDeleteGraffiti() throws JsonProcessingException {
     final Validator validator = new Validator(publicKey, NO_OP_SIGNER, Optional::empty);
     when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.of(validator));
 
@@ -89,7 +89,7 @@ void shouldReturnErrorWhenIssueDeletingGraffiti()
   }
 
   @Test
-  void shouldRespondNotFoundWhenNoValidator() throws IOException {
+  void shouldRespondNotFoundWhenNoValidator() throws JsonProcessingException {
     when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.empty());
 
     handler.handleRequest(request);

validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffitiTest.java

@@ -62,17 +62,17 @@ class GetGraffitiTest {
           .build();
 
   @Test
-  void shouldGetGraffiti() throws Throwable {
+  void shouldGetGraffiti() throws JsonProcessingException {
     checkGraffiti(Optional.of(bytesGraffiti));
   }
 
   @Test
-  void shouldGetEmptyGraffiti() throws Throwable {
+  void shouldGetEmptyGraffiti() throws JsonProcessingException {
     checkGraffiti(Optional.empty());
   }
 
   @Test
-  void shouldHandleGraffitiManagementException() throws Throwable {
+  void shouldHandleGraffitiManagementException() throws JsonProcessingException {
     final GraffitiManagementException exception =
         new GraffitiManagementException("Unable to retrieve graffiti from storage");
     final UpdatableGraffitiProvider provider = mock(UpdatableGraffitiProvider.class);
@@ -131,7 +131,7 @@ void metadata_shouldHandle500() throws JsonProcessingException {
     verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR);
   }
 
-  private void checkGraffiti(final Optional<Bytes32> graffiti) throws Throwable {
+  private void checkGraffiti(final Optional<Bytes32> graffiti) throws JsonProcessingException {
     final UpdatableGraffitiProvider provider = mock(UpdatableGraffitiProvider.class);
     when(provider.getUnsafe()).thenReturn(graffiti);
     final Validator validator = new Validator(publicKey, NO_OP_SIGNER, provider);

validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/SetGraffitiTest.java

@@ -33,7 +33,6 @@
 import static tech.pegasys.teku.spec.generator.signatures.NoOpLocalSigner.NO_OP_SIGNER;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import java.io.IOException;
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
 import tech.pegasys.teku.bls.BLSPublicKey;
@@ -62,7 +61,7 @@ class SetGraffitiTest {
           .build();
 
   @Test
-  void shouldSuccessfullySetGraffiti() throws IOException, GraffitiManagementException {
+  void shouldSuccessfullySetGraffiti() throws JsonProcessingException {
     request.setRequestBody(graffiti);
 
     final Validator validator = new Validator(publicKey, NO_OP_SIGNER, Optional::empty);
@@ -76,7 +75,7 @@ void shouldSuccessfullySetGraffiti() throws IOException, GraffitiManagementExcep
   }
 
   @Test
-  void shouldReturnErrorWhenIssueSettingGraffiti() throws IOException, GraffitiManagementException {
+  void shouldReturnErrorWhenIssueSettingGraffiti() throws JsonProcessingException {
     final GraffitiManagementException exception =
         new GraffitiManagementException("Unable to update graffiti for validator " + publicKey);
     request.setRequestBody(graffiti);
@@ -94,7 +93,7 @@ void shouldReturnErrorWhenIssueSettingGraffiti() throws IOException, GraffitiMan
   }
 
   @Test
-  void shouldThrowExceptionWhenInvalidGraffitiInput() throws GraffitiManagementException {
+  void shouldThrowExceptionWhenInvalidGraffitiInput() {
     final String invalidGraffiti = "This graffiti is a bit too long!!";
     final String errorMessage =
         String.format(
@@ -114,7 +113,7 @@ void shouldThrowExceptionWhenInvalidGraffitiInput() throws GraffitiManagementExc
   }
 
   @Test
-  void shouldRespondNotFoundWhenNoValidator() throws IOException {
+  void shouldRespondNotFoundWhenNoValidator() throws JsonProcessingException {
     when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.empty());
 
     handler.handleRequest(request);