code cov

Signed-off-by: karenx <karenx@uber.com>

Author: karenx

modules/transport-grpc/src/test/java/org/opensearch/transport/grpc/Netty4GrpcServerTransportTests.java

@@ -12,6 +12,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.transport.grpc.ssl.NettyGrpcClient;
@@ -324,6 +325,209 @@ public void testExecutorCountSettingsValidation() {
         expectThrows(IllegalArgumentException.class, () -> { new Netty4GrpcServerTransport(invalidSettings, services, networkService); });
     }
 
+    public void testStartFailureTriggersCleanup() {
+        // Create a transport that will fail to start
+        Settings settingsWithInvalidPort = Settings.builder()
+            .put(Netty4GrpcServerTransport.SETTING_GRPC_PORT.getKey(), "999999") // Invalid port
+            .build();
+
+        Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settingsWithInvalidPort, services, networkService);
+
+        // Start should fail
+        expectThrows(Exception.class, transport::start);
+
+        // Resources should be cleaned up after failure - the implementation calls doStop() in the finally block
+        ExecutorService executor = transport.getGrpcExecutorForTesting();
+        EventLoopGroup bossGroup = transport.getBossEventLoopGroupForTesting();
+        EventLoopGroup workerGroup = transport.getWorkerEventLoopGroupForTesting();
+
+        // Resources may still exist but should be shutdown
+        if (executor != null) {
+            assertTrue("Executor should be shutdown after failed start", executor.isShutdown());
+        }
+        if (bossGroup != null) {
+            assertTrue("Boss group should be shutdown after failed start", bossGroup.isShutdown());
+        }
+        if (workerGroup != null) {
+            assertTrue("Worker group should be shutdown after failed start", workerGroup.isShutdown());
+        }
+
+        // Close should still be safe to call
+        transport.close();
+    }
+
+    public void testInterruptedShutdownHandling() throws InterruptedException {
+        Settings settings = createSettings();
+        Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService);
+
+        transport.start();
+
+        // Interrupt the current thread to test interrupt handling
+        Thread.currentThread().interrupt();
+
+        // Stop should handle the interrupt gracefully
+        transport.stop();
+
+        // Clear interrupt status
+        Thread.interrupted();
+
+        transport.close();
+    }
+
+    public void testInvalidHostBinding() {
+        // Test with invalid bind host to trigger host resolution error
+        Settings settings = Settings.builder()
+            .put(Netty4GrpcServerTransport.SETTING_GRPC_PORT.getKey(), OpenSearchTestCase.getPortRange())
+            .put(Netty4GrpcServerTransport.SETTING_GRPC_BIND_HOST.getKey(), "invalid.host.that.does.not.exist")
+            .build();
+
+        Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService);
+
+        // Start should fail due to host resolution failure
+        expectThrows(Exception.class, transport::start);
+
+        transport.close();
+    }
+
+    public void testPublishPortResolutionFailure() {
+        // Create settings that will cause publish port resolution to fail
+        Settings settings = Settings.builder()
+            .put(Netty4GrpcServerTransport.SETTING_GRPC_PORT.getKey(), "0") // Dynamic port
+            .put(Netty4GrpcServerTransport.SETTING_GRPC_PUBLISH_PORT.getKey(), "65536") // Invalid publish port
+            .build();
+
+        Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService);
+
+        // Start should fail due to publish port resolution
+        expectThrows(Exception.class, transport::start);
+
+        transport.close();
+    }
+
+    public void testMultipleBindAddresses() {
+        // Test binding to multiple localhost addresses
+        Settings settings = Settings.builder()
+            .put(Netty4GrpcServerTransport.SETTING_GRPC_PORT.getKey(), OpenSearchTestCase.getPortRange())
+            .putList(Netty4GrpcServerTransport.SETTING_GRPC_BIND_HOST.getKey(), "127.0.0.1", "localhost")
+            .build();
+
+        try (Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService)) {
+            transport.start();
+
+            BoundTransportAddress boundAddress = transport.getBoundAddress();
+            assertNotNull("Bound address should not be null", boundAddress);
+            assertTrue("Should have at least one bound address", boundAddress.boundAddresses().length > 0);
+
+            transport.stop();
+        }
+    }
+
+    public void testShutdownTimeoutHandling() throws InterruptedException {
+        Settings settings = createSettings();
+        Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService);
+
+        transport.start();
+
+        // Get references to the thread pools
+        ExecutorService executor = transport.getGrpcExecutorForTesting();
+        EventLoopGroup bossGroup = transport.getBossEventLoopGroupForTesting();
+        EventLoopGroup workerGroup = transport.getWorkerEventLoopGroupForTesting();
+
+        assertNotNull("Executor should be created", executor);
+        assertNotNull("Boss group should be created", bossGroup);
+        assertNotNull("Worker group should be created", workerGroup);
+
+        // Normal shutdown should work
+        transport.stop();
+
+        // Verify everything is shutdown
+        assertTrue("Executor should be shutdown", executor.isShutdown());
+        assertTrue("Boss group should be shutdown", bossGroup.isShutdown());
+        assertTrue("Worker group should be shutdown", workerGroup.isShutdown());
+
+        transport.close();
+    }
+
+    public void testResourceCleanupOnClose() {
+        Settings settings = createSettings();
+        Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService);
+
+        transport.start();
+        transport.stop();
+
+        // doClose should handle cleanup gracefully even if resources are already shutdown
+        transport.close();
+
+        // Multiple closes should be safe
+        transport.close();
+    }
+
+    public void testPortRangeHandling() {
+        // Test with a port range
+        Settings settings = Settings.builder().put(Netty4GrpcServerTransport.SETTING_GRPC_PORT.getKey(), "9300-9400").build();
+
+        try (Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService)) {
+            transport.start();
+
+            BoundTransportAddress boundAddress = transport.getBoundAddress();
+            assertNotNull("Bound address should not be null", boundAddress);
+
+            int actualPort = boundAddress.publishAddress().getPort();
+            assertTrue("Port should be in range 9300-9400", actualPort >= 9300 && actualPort <= 9400);
+
+            transport.stop();
+        }
+    }
+
+    public void testGracefulShutdownWithException() {
+        // Test that exceptions during shutdown don't prevent cleanup
+        Settings settings = createSettings();
+        Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService);
+
+        transport.start();
+
+        // Simulate an interruption during shutdown to test exception handling paths
+        ExecutorService executor = transport.getGrpcExecutorForTesting();
+        EventLoopGroup bossGroup = transport.getBossEventLoopGroupForTesting();
+        EventLoopGroup workerGroup = transport.getWorkerEventLoopGroupForTesting();
+
+        assertNotNull("Executor should be created", executor);
+        assertNotNull("Boss group should be created", bossGroup);
+        assertNotNull("Worker group should be created", workerGroup);
+
+        // Force shutdown to test the interrupt handling code paths
+        executor.shutdownNow();
+        bossGroup.shutdownGracefully(0, 0, java.util.concurrent.TimeUnit.MILLISECONDS);
+        workerGroup.shutdownGracefully(0, 0, java.util.concurrent.TimeUnit.MILLISECONDS);
+
+        // Now call stop - it should handle the already shutdown resources gracefully
+        transport.stop();
+        transport.close();
+
+        // Verify everything is still properly shutdown
+        assertTrue("Executor should be shutdown", executor.isShutdown());
+        assertTrue("Boss group should be shutdown", bossGroup.isShutdown());
+        assertTrue("Worker group should be shutdown", workerGroup.isShutdown());
+    }
+
+    public void testCloseWithNullResources() {
+        // Test that close() handles null resources gracefully
+        Settings settings = createSettings();
+        Netty4GrpcServerTransport transport = new Netty4GrpcServerTransport(settings, services, networkService);
+
+        // Don't start the transport, so resources should be null
+        assertNull("Boss group should be null before start", transport.getBossEventLoopGroupForTesting());
+        assertNull("Worker group should be null before start", transport.getWorkerEventLoopGroupForTesting());
+        assertNull("Executor should be null before start", transport.getGrpcExecutorForTesting());
+
+        // Close should handle null resources gracefully
+        transport.close();
+
+        // Multiple closes should be safe
+        transport.close();
+        transport.close();
+    }
+
     private static Settings createSettings() {
         return Settings.builder().put(Netty4GrpcServerTransport.SETTING_GRPC_PORT.getKey(), OpenSearchTestCase.getPortRange()).build();
     }