Disable connection check at every query (#525)

* testing ping call

* creating toggle

* release notes

* [Gradle Release Plugin] - new version commit:  '3.25.3-snapshot'.

* testing ping on specified port

* testing ping api

Author: mageddo

RELEASE-NOTES.md

@@ -1,3 +1,6 @@
+## 3.25.3
+* Resources utilization optimization by disabling connection check at every query #524
+
 ## 3.25.2
 * Migrating cache to caffeine #522
 

gradle.properties

@@ -1 +1 @@
-version=3.25.2-snapshot
+version=3.25.3-snapshot

src/main/java/com/mageddo/dnsproxyserver/solver/SolverRemote.java

@@ -83,15 +83,25 @@ Request buildRequest(Message query, int resolverIndex, StopWatch stopWatch, Reso
 
   Result safeQueryResult(Request req) {
     req.splitStopWatch();
-    return this.circuitBreakerService.safeHandle(req.getResolverAddress(), () -> this.queryResultWhilePingingResolver(req));
+    return this.circuitBreakerService.safeHandle(req.getResolverAddress(), () -> this.queryResult(req));
   }
 
-  Result queryResultWhilePingingResolver(Request req) {
+  Result queryResult(Request req) {
     final var resFuture = req.sendQueryAsyncToResolver(this.delegate.getExecutor());
-    this.netWatchdog.watch(req.getResolverAddr(), resFuture, PING_TIMEOUT_IN_MS);
+    if (this.isPingWhileGettingQueryResponseActive()) {
+      this.pingWhileGettingQueryResponse(req, resFuture);
+    }
     return this.transformToResult(resFuture, req);
   }
 
+  void pingWhileGettingQueryResponse(Request req, CompletableFuture<Message> resFuture) {
+    this.netWatchdog.watch(req.getResolverAddr(), resFuture, PING_TIMEOUT_IN_MS);
+  }
+
+  boolean isPingWhileGettingQueryResponseActive() {
+    return Boolean.getBoolean("mg.solverRemote.pingWhileGettingQueryResponse");
+  }
+
   Result transformToResult(CompletableFuture<Message> resFuture, Request request) {
     final var res = this.findFutureRes(resFuture, request);
     if (res == null) {

src/main/java/com/mageddo/net/IpAddr.java

@@ -44,6 +44,11 @@ public static IpAddr of(String addr) {
     return IpUtils.toIpAddr(addr);
   }
 
+
+  public static IpAddr of(String ip, int port) {
+    return IpAddr.of(IP.of(ip), port);
+  }
+
   public static IpAddr of(IP ip) {
     return of(ip, null);
   }

src/main/java/com/mageddo/net/IpAddrs.java

@@ -5,10 +5,15 @@
 import java.net.InetSocketAddress;
 
 public class IpAddrs {
-  public static IpAddr from(InetSocketAddress inetSocketAddress){
+  public static IpAddr from(InetSocketAddress inetSocketAddress) {
     return IpAddr.of(
       Ips.from(inetSocketAddress.getAddress()),
       inetSocketAddress.getPort()
     );
   }
+
+  public static InetSocketAddress toInetSocketAddress(IpAddr ipAddr) {
+    return new InetSocketAddress(ipAddr.getIp().toInetAddr(), ipAddr.getPort());
+  }
+
 }

src/main/java/com/mageddo/net/Networks.java

@@ -105,7 +105,7 @@ public static String findIP(ContainerNetwork network, IP.Version version) {
     };
   }
 
-  public static boolean ping(String ip, int port, int timeout){
+  public static boolean ping(String ip, int port, int timeout) {
     try {
       final InetAddress addr = InetAddress.getByAddress(Ips.toBytes(ip));
       return ping(addr, port, timeout);

src/main/java/com/mageddo/net/SocketUtils.java

@@ -13,4 +13,9 @@ public static int findRandomFreePort() {
       return server.getLocalPort();
     }
   }
+
+  @SneakyThrows
+  public static ServerSocket createServerOnRandomPort(){
+    return new ServerSocket(0);
+  }
 }

src/test/java/com/mageddo/dnsproxyserver/solver/SolverRemoteTest.java

@@ -19,10 +19,14 @@
 import java.util.concurrent.Executor;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.verify;
 
 @ExtendWith(MockitoExtension.class)
 class SolverRemoteTest {
@@ -45,7 +49,8 @@ class SolverRemoteTest {
 
   @BeforeEach
   void beforeEach (){
-    doReturn(Executors.newThreadExecutor())
+    lenient()
+      .doReturn(Executors.newThreadExecutor())
       .when(this.resolvers)
       .getExecutor();
   }
@@ -162,4 +167,48 @@ void mustReturnRaEvenWhenRemoteServerDoesntReturnsRA() throws Exception {
     assertEquals(Response.DEFAULT_SUCCESS_TTL, result.getDpsTtl());
   }
 
+  @Test
+  void mustPingRemoteServerWhileQueryingWhenFeatureIsActive(){
+
+    // arrange
+    final var query = MessageTemplates.acmeAQuery();
+    final var answer = MessageTemplates.buildAAnswer(query);
+
+    doReturn(true).when(this.solverRemote).isPingWhileGettingQueryResponseActive();
+
+    doReturn(InetSocketAddressTemplates._8_8_8_8())
+      .when(this.resolver)
+      .getAddress()
+    ;
+
+    doReturn(CompletableFuture.completedFuture(answer))
+      .when(this.resolver)
+      .sendAsync(any(), any(Executor.class));
+
+    doReturn(List.of(this.resolver))
+      .when(this.resolvers)
+      .resolvers()
+    ;
+
+    // act
+    final var res = this.solverRemote.handle(query);
+
+    // assert
+    assertNotNull(res);
+    verify(this.solverRemote).pingWhileGettingQueryResponse(any(), any());
+
+  }
+
+  @Test
+  void pingRemoteServerWhileQueryingDisabledByDefault(){
+
+    // act
+    final var active = this.solverRemote.isPingWhileGettingQueryResponseActive();
+
+    // assert
+    assertFalse(active);
+
+  }
+
+
 }

src/test/java/com/mageddo/dnsproxyserver/solver/remote/application/CircuitBreakerCheckerServiceTest.java

@@ -1,5 +1,8 @@
 package com.mageddo.dnsproxyserver.solver.remote.application;
 
+import com.mageddo.dnsproxyserver.solver.remote.Result;
+import com.mageddo.net.SocketUtils;
+import dev.failsafe.CircuitBreaker;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
@@ -8,6 +11,8 @@
 import testing.templates.InetSocketAddressTemplates;
 import testing.templates.solver.remote.FailSafeCircuitBreakerTemplates;
 
+import java.net.InetSocketAddress;
+
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
@@ -63,4 +68,22 @@ void mustReturnFalseWhenThereIsAFatalException() {
     assertFalse(ok);
   }
 
+  @Test
+  void mustPingSpecifiedPort() throws Exception {
+
+    // arrange
+    final var server = SocketUtils.createServerOnRandomPort();
+    final var address = (InetSocketAddress) server.getLocalSocketAddress();
+    final var circuitBreaker = CircuitBreaker.<Result>builder().build();
+
+    try (server) {
+      // act
+      final var success = this.service.safeCheck(address, circuitBreaker);
+
+      // assert
+      assertTrue(success);
+    }
+
+  }
+
 }

src/test/java/com/mageddo/net/NetworksTest.java

@@ -1,14 +1,16 @@
 package com.mageddo.net;
 
-import testing.templates.IpTemplates;
-import testing.templates.NetworkInterfaceTemplates;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Spy;
 import org.mockito.junit.jupiter.MockitoExtension;
+import testing.templates.IpTemplates;
+import testing.templates.NetworkInterfaceTemplates;
+
+import java.net.InetSocketAddress;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -25,17 +27,17 @@ class NetworksTest {
   Network network;
 
   @BeforeAll
-  static void beforeAll(){
+  static void beforeAll() {
     realNetwork = Networks.network;
   }
 
   @AfterAll
-  static void afterAll(){
+  static void afterAll() {
     Networks.network = realNetwork;
   }
 
   @BeforeEach
-  void before(){
+  void before() {
     Networks.network = this.network;
   }
 
@@ -77,4 +79,21 @@ void mustPreferNonLoopbackAddresses() {
     assertEquals(IpTemplates.LOCAL_192, ip.toText());
   }
 
+  @Test
+  void mustPingSpecifiedPort() throws Exception {
+
+    // arrange
+    final var server = SocketUtils.createServerOnRandomPort();
+    final var address = (InetSocketAddress) server.getLocalSocketAddress();
+
+    try (server) {
+      // act
+      final var success = Networks.ping(address, 1000);
+
+      // assert
+      assertTrue(success);
+    }
+
+  }
+
 }