fix: Added throws IOException to propagate exceptions upstream

Signed-off-by: Matt Peterson <[email protected]>

Author: mattp-swirldslabs

server/src/main/java/com/hedera/block/server/persistence/BlockPersistenceHandler.java

@@ -32,19 +32,20 @@ public interface BlockPersistenceHandler<U, V> {
     void persist(final U blockItem) throws IOException;
 
     /**
-     * Reads a block.
+     * Retrieves a block using the block number.
      *
      * @param blockNumber the number of the block to read
      * @return an Optional of the block
      */
-    Optional<V> read(final long blockNumber);
+    Optional<V> retrieve(final long blockNumber) throws IOException;
 
     /**
-     * Reads a range of blocks.
+     * Retrieves an ordered collection of items (e.g. Blocks) within a range.
      *
      * @param startBlockNumber the id of the first block to read
      * @param endBlockNumber the id of the last block to read
      * @return a queue of blocks
      */
-    Queue<V> readRange(final long startBlockNumber, final long endBlockNumber);
+    Queue<V> retrieveRange(final long startBlockNumber, final long endBlockNumber)
+            throws IOException;
 }

server/src/main/java/com/hedera/block/server/persistence/WriteThroughCacheHandler.java renamed to server/src/main/java/com/hedera/block/server/persistence/FileSystemPersistenceHandler.java

@@ -50,10 +50,11 @@ public WriteThroughCacheHandler(
      * @return a queue of blocks
      */
     @Override
-    public Queue<Block> readRange(final long startBlockId, final long endBlockId) {
+    public Queue<Block> retrieveRange(final long startBlockId, final long endBlockId)
+            throws IOException {
         final Queue<Block> blocks = new LinkedList<>();
         for (long count = startBlockId; count <= endBlockId; count++) {
-            final Optional<Block> blockOpt = read(count);
+            final Optional<Block> blockOpt = retrieve(count);
             blockOpt.ifPresent(blocks::add);
         }
 
@@ -68,7 +69,7 @@ public Queue<Block> readRange(final long startBlockId, final long endBlockId) {
      * @return an Optional with the block
      */
     @Override
-    public Optional<Block> read(final long id) {
+    public Optional<Block> retrieve(final long id) throws IOException {
         return blockReader.read(id);
     }
 

server/src/main/java/com/hedera/block/server/persistence/storage/BlockAsDirReader.java

@@ -47,7 +47,7 @@ public BlockAsDirReader(final String key, final Config config) {
         this.blockNodeRootPath = blockNodeRootPath;
     }
 
-    public Optional<Block> read(final long blockNumber) {
+    public Optional<Block> read(final long blockNumber) throws IOException {
 
         // Construct the path to the requested Block
         final Path blockPath = blockNodeRootPath.resolve(String.valueOf(blockNumber));
@@ -66,17 +66,10 @@ public Optional<Block> read(final long blockNumber) {
         final Builder builder = Block.newBuilder();
         for (int i = 1; ; i++) {
             final Path blockItemPath = blockPath.resolve(i + BLOCK_FILE_EXTENSION);
-            try {
-                final Optional<BlockItem> blockItemOpt = readBlockItem(blockItemPath.toString());
-                if (blockItemOpt.isPresent()) {
-                    builder.addBlockItems(blockItemOpt.get());
-                    continue;
-                }
-            } catch (IOException io) {
-                // Return an empty Optional signaling an error.  It's all or nothing
-                // when retrieving a Block
-                LOGGER.log(System.Logger.Level.ERROR, "Error reading file: " + blockItemPath, io);
-                return Optional.empty();
+            final Optional<BlockItem> blockItemOpt = readBlockItem(blockItemPath.toString());
+            if (blockItemOpt.isPresent()) {
+                builder.addBlockItems(blockItemOpt.get());
+                continue;
             }
 
             break;

server/src/main/java/com/hedera/block/server/persistence/storage/BlockReader.java

@@ -16,8 +16,9 @@
 
 package com.hedera.block.server.persistence.storage;
 
+import java.io.IOException;
 import java.util.Optional;
 
 public interface BlockReader<V> {
-    Optional<V> read(final long blockNumber);
+    Optional<V> read(final long blockNumber) throws IOException;
 }

server/src/test/java/com/hedera/block/server/persistence/WriteThroughCacheHandlerTest.java renamed to server/src/test/java/com/hedera/block/server/persistence/FileSystemPersistenceHandlerTest.java

@@ -91,10 +91,11 @@ private static void persistBlockItems(
     }
 
     private static void verifyBlocks(
-            int numOfBlocks, BlockPersistenceHandler<BlockItem, Block> blockPersistenceHandler) {
+            int numOfBlocks, BlockPersistenceHandler<BlockItem, Block> blockPersistenceHandler)
+            throws IOException {
 
         for (int i = 1; i <= numOfBlocks; i++) {
-            Optional<Block> blockOpt = blockPersistenceHandler.read(i);
+            Optional<Block> blockOpt = blockPersistenceHandler.retrieve(i);
             if (blockOpt.isEmpty()) {
                 fail("Block not found: " + i);
             } else {

server/src/test/java/com/hedera/block/server/persistence/RangeTest.java

@@ -50,11 +50,11 @@ public void testReadRangeWithEvenEntries() throws IOException {
     }
 
     @Test
-    public void testReadRangeWithNoBlocks() {
+    public void testReadRangeWithNoBlocks() throws IOException {
 
         BlockPersistenceHandler<BlockItem, Block> blockPersistenceHandler =
                 generateInMemoryTestBlockPersistenceHandler();
-        Queue<Block> results = blockPersistenceHandler.readRange(1, 100);
+        Queue<Block> results = blockPersistenceHandler.retrieveRange(1, 100);
         assertNotNull(results);
         assertEquals(0, results.size());
     }
@@ -72,21 +72,21 @@ public void testReadRangeWhenBlocksLessThanWindow() throws IOException {
 
         int window = 10;
 
-        Queue<Block> results = blockPersistenceHandler.readRange(1, window);
+        Queue<Block> results = blockPersistenceHandler.retrieveRange(1, window);
         assertNotNull(results);
         assertEquals(numOfBlocks, results.size());
     }
 
     private static void verifyReadRange(
             int window,
             int numOfWindows,
-            BlockPersistenceHandler<BlockItem, Block> blockPersistenceHandler) {
+            BlockPersistenceHandler<BlockItem, Block> blockPersistenceHandler) throws IOException {
 
         for (int j = 0; j < numOfWindows; ++j) {
 
             int startBlockId = (j * window) + 1;
             int endBlockId = (startBlockId + window) - 1;
-            Queue<Block> results = blockPersistenceHandler.readRange(startBlockId, endBlockId);
+            Queue<Block> results = blockPersistenceHandler.retrieveRange(startBlockId, endBlockId);
 
             for (int i = startBlockId; i <= endBlockId && results.peek() != null; ++i) {
                 Block block = results.poll();

server/src/test/java/com/hedera/block/server/persistence/storage/BlockAsDirectoryTest.java

@@ -104,7 +104,7 @@ public void testWriterAndReaderHappyPath() throws IOException {
     }
 
     @Test
-    public void testBlockDoesNotExist() {
+    public void testBlockDoesNotExist() throws IOException {
         BlockReader<Block> blockReader = new BlockAsDirReader(JUNIT, testConfig);
         Optional<Block> blockOpt = blockReader.read(10000);
         assertTrue(blockOpt.isEmpty());
@@ -137,8 +137,7 @@ public void testRemoveBlockItemReadPerms() throws IOException {
         removeBlockItemReadPerms(1, 1, testConfig);
 
         BlockReader<Block> blockReader = new BlockAsDirReader(JUNIT, testConfig);
-        Optional<Block> blockOpt = blockReader.read(1);
-        assertTrue(blockOpt.isEmpty());
+        assertThrows(IOException.class, () -> blockReader.read(1));
     }
 
     @Test