Merge pull request #300 from rsiatka/master

sebastianlorenzo88 · web-flow · commit 858329e06cf9 · 2025-07-14T17:55:03.000-03:00
Add support for connection Keep-Alive
diff --git a/docs/guide/protocols/http/index.md b/docs/guide/protocols/http/index.md
@@ -14,6 +14,7 @@ Here we show some of them, but check [JmeterDsl](/jmeter-java-dsl/src/main/java/
 <!-- @include: connections.md -->
 <!-- @include: embedded-resources.md -->
 <!-- @include: redirects.md -->
+<!-- @include: keepAlive.md -->
 <!-- @include: defaults.md -->
 <!-- @include: override-defaults.md -->
 <!-- @include: proxy.md -->
diff --git a/docs/guide/protocols/http/keepAlive.md b/docs/guide/protocols/http/keepAlive.md
@@ -0,0 +1,39 @@
+#### Keep alive
+
+Jmeter-java-dsl maintains a persistent http connection for subsequent requests to the same server.
+It is done by sending `Connection: keep-alive` header.
+If you want to disable keep-alive logic and force a server to close connection after each request then use`.useKeepAlive(false)` in a given `httpSampler` or `httpDefaults`.
+
+
+```java
+import static us.abstracta.jmeter.javadsl.JmeterDsl.*;
+import org.junit.jupiter.api.Test;
+public class PerformanceTest {
+
+  @Test
+  public void test1() throws Exception {
+    testPlan(
+        threadGroup(1, 10,
+            httpSampler("https://myservice1.com")
+                .useKeepAlive(false), 
+            httpSampler("https://myservice2.com")
+                .useKeepAlive(true),
+            httpSampler("https://myservice3.com")
+        )
+    ).run();
+  }
+
+  @Test
+  public void test2() throws Exception {      
+    testPlan(
+        httpDefaults()
+            .useKeepAlive(false), 
+        threadGroup(1, 10,
+            httpSampler("https://myservice1.com"),
+            httpSampler("https://myservice2.com")
+       )
+    ).run();
+  }
+
+}
+```
diff --git a/jmeter-java-dsl/src/main/java/us/abstracta/jmeter/javadsl/http/DslHttpDefaults.java b/jmeter-java-dsl/src/main/java/us/abstracta/jmeter/javadsl/http/DslHttpDefaults.java
@@ -53,6 +53,7 @@ public class DslHttpDefaults extends BaseConfigElement {
   protected String proxyUser;
   protected String proxyPassword;
   protected HttpClientImpl clientImpl;
+  protected Boolean useKeepAlive;
   protected Boolean followRedirects;
 
   public DslHttpDefaults() {
@@ -189,6 +190,18 @@ public DslHttpDefaults followRedirects(boolean enable) {
     return this;
   }
 
+  /**
+   * Specifies if by default HTTP connection should be kept alive.
+   *
+   * @param enable sets either to enable or disable persistent connection
+   * @return the config element for further configuration or usage.
+   * @since 1.30
+   */
+  public DslHttpDefaults useKeepAlive(boolean enable) {
+    this.useKeepAlive = enable;
+    return this;
+  }
+
   /**
    * Allows enabling automatic download of HTML embedded resources (images, iframes, etc) by
    * default.
@@ -430,6 +443,9 @@ public HashTree buildTreeUnder(HashTree parent, BuildTreeContext context) {
     if (followRedirects != null) {
       buildEndListener(context.getParent()).followRedirects = followRedirects;
     }
+    if (useKeepAlive != null) {
+      buildEndListener(context.getParent()).useKeepAlive = useKeepAlive;
+    }
     return ret;
   }
 
@@ -445,11 +461,19 @@ protected static void addPendingFollowRedirectsElement(HTTPSamplerProxy element,
     buildEndListener(context.getRoot()).pendingFollowRedirectsElements.add(element);
   }
 
+  protected static void addPendingUseKeepAliveElement(HTTPSamplerProxy element,
+      BuildTreeContext context) {
+    buildEndListener(context.getRoot()).pendingUseKeepAliveElements.add(element);
+  }
+
   private static class DefaultsTreeContextEndListener implements TreeContextEndListener {
 
     private Boolean followRedirects;
     private final List<HTTPSamplerProxy> pendingFollowRedirectsElements = new ArrayList<>();
 
+    private Boolean useKeepAlive;
+    private final List<HTTPSamplerProxy> pendingUseKeepAliveElements = new ArrayList<>();
+
     private DefaultsTreeContextEndListener(BuildTreeContext context) {
       context.addEndListener(this);
     }
@@ -463,6 +487,14 @@ public void execute(BuildTreeContext context, HashTree tree) {
             .filter(e -> e.getPropertyAsString(HTTPSamplerBase.FOLLOW_REDIRECTS).isEmpty())
             .forEach(e -> e.setFollowRedirects(true));
       }
+
+      if (useKeepAlive != null) {
+        setChildrenToUseKeepAlive(tree);
+      } else {
+        pendingUseKeepAliveElements.stream()
+            .filter(e -> e.getPropertyAsString(HTTPSamplerBase.USE_KEEPALIVE).isEmpty())
+            .forEach(e -> e.setUseKeepAlive(true));
+      }
     }
 
     private void setChildrenToFollowRedirects(HashTree tree) {
@@ -478,6 +510,19 @@ private void setChildrenToFollowRedirects(HashTree tree) {
       });
     }
 
+    private void setChildrenToUseKeepAlive(HashTree tree) {
+      tree.forEach((key, value) -> {
+        if (key instanceof HTTPSamplerProxy) {
+          HTTPSamplerProxy sampler = (HTTPSamplerProxy) key;
+          if (sampler.getPropertyAsString(HTTPSamplerBase.USE_KEEPALIVE).isEmpty()) {
+            sampler.setUseKeepAlive(useKeepAlive);
+          }
+        } else {
+          setChildrenToUseKeepAlive(value);
+        }
+      });
+    }
+
   }
 
   public static class CodeBuilder extends SingleGuiClassCallBuilder {
@@ -524,12 +569,16 @@ public void registerDependency(MethodCallContext context) {
       boolean followRedirects =
           isDefaultCandidate || testElement.getPropertyAsBoolean(HTTPSamplerBase.FOLLOW_REDIRECTS);
       endListener.registerFollowRedirect(followRedirects, context, isDefaultCandidate);
+      boolean useKeepAlive =
+              isDefaultCandidate || testElement.getPropertyAsBoolean(HTTPSamplerBase.USE_KEEPALIVE);
+      endListener.registerUseKeepAlive(useKeepAlive, context, isDefaultCandidate);
     }
 
     private static class DefaultsMethodContextEndListener implements MethodCallContextEndListener {
 
       private final List<EncodedCall> encodedCalls = new ArrayList<>();
       private final List<RedirectableCall> redirectableCalls = new ArrayList<>();
+      private final List<UseKeepAliveCall> useKeepAliveCalls = new ArrayList<>();
 
       private DefaultsMethodContextEndListener(MethodCallContext parentCtx) {
         parentCtx.addEndListener(this);
@@ -545,10 +594,16 @@ public void registerFollowRedirect(boolean followRedirects, MethodCallContext re
         redirectableCalls.add(new RedirectableCall(followRedirects, ret, isDefaultCandidate));
       }
 
+      public void registerUseKeepAlive(boolean useKeepAlive, MethodCallContext ret,
+          boolean isDefaultCandidate) {
+        useKeepAliveCalls.add(new UseKeepAliveCall(useKeepAlive, ret, isDefaultCandidate));
+      }
+
       @Override
       public void execute(MethodCallContext ctx, MethodCall ret) {
         solveDefaultEncoding(ctx);
         solveDefaultFollowRedirects(ctx);
+        solveDefaultUseKeepAlive(ctx);
       }
 
       private void solveDefaultEncoding(MethodCallContext ctx) {
@@ -623,6 +678,21 @@ private void solveDefaultFollowRedirects(MethodCallContext ctx) {
         }
       }
 
+      private void solveDefaultUseKeepAlive(MethodCallContext ctx) {
+        UseKeepAliveCall defaultsCall = findDefaultUseKeepAliveCall(ctx);
+        if (defaultsCall != null) {
+          useKeepAliveCalls.stream()
+                  .filter(c -> c != defaultsCall)
+                  .forEach(UseKeepAliveCall::removeUseKeepAlive);
+        }
+        DefaultsMethodContextEndListener parentListener = buildParentContextEndListener(ctx);
+        if (parentListener != null) {
+          parentListener.registerUseKeepAlive(
+                  defaultsCall == null || defaultsCall.useKeepAlive,
+                  defaultsCall != null ? defaultsCall.ctx : null, false);
+        }
+      }
+
       private RedirectableCall findDefaultRedirectableCall(MethodCallContext ctx) {
         if (redirectableCalls.size() == 1) {
           return redirectableCalls.get(0);
@@ -641,6 +711,24 @@ private RedirectableCall findDefaultRedirectableCall(MethodCallContext ctx) {
         return null;
       }
 
+      private UseKeepAliveCall findDefaultUseKeepAliveCall(MethodCallContext ctx) {
+        if (useKeepAliveCalls.size() == 1) {
+          return useKeepAliveCalls.get(0);
+        }
+        if (useKeepAliveCalls.stream().allMatch(c -> c.isDefaultCandidate || !c.useKeepAlive)) {
+          UseKeepAliveCall ret = useKeepAliveCalls.stream()
+                  .filter(c -> c.isDefaultCandidate)
+                  .findAny()
+                  .orElse(null);
+          if (ret == null) {
+            ret = new UseKeepAliveCall(false, buildDefaultsCall(ctx), true);
+          }
+          ret.setUseKeepAlive(false);
+          return ret;
+        }
+        return null;
+      }
+
     }
 
   }
@@ -702,4 +790,29 @@ public void removeFollowRedirects() {
 
   }
 
+  private static class UseKeepAliveCall {
+
+    private boolean useKeepAlive;
+    private final MethodCallContext ctx;
+    private final boolean isDefaultCandidate;
+
+    private UseKeepAliveCall(boolean useKeepAlive, MethodCallContext ctx,
+                             boolean isDefaultCandidate) {
+      this.useKeepAlive = useKeepAlive;
+      this.ctx = ctx;
+      this.isDefaultCandidate = isDefaultCandidate;
+    }
+
+    public void setUseKeepAlive(boolean useKeepAlive) {
+      this.useKeepAlive = useKeepAlive;
+      ctx.getMethodCall().chain("useKeepAlive", new BoolParam(useKeepAlive, true));
+    }
+
+    public void removeUseKeepAlive() {
+      ctx.getMethodCall().unchain("useKeepAlive");
+      removeEmptyDefaultsCall(ctx);
+    }
+
+  }
+
 }
diff --git a/jmeter-java-dsl/src/main/java/us/abstracta/jmeter/javadsl/http/DslHttpSampler.java b/jmeter-java-dsl/src/main/java/us/abstracta/jmeter/javadsl/http/DslHttpSampler.java
@@ -50,6 +50,7 @@ public class DslHttpSampler extends DslBaseHttpSampler<DslHttpSampler> {
   protected final List<HTTPFileArg> files = new ArrayList<>();
   protected Charset encoding;
   protected Boolean followRedirects;
+  protected Boolean useKeepAlive;
   protected boolean downloadEmbeddedResources;
   protected String embeddedResourcesMatchRegex;
   protected String embeddedResourcesNotMatchRegex;
@@ -299,6 +300,23 @@ public DslHttpSampler followRedirects(boolean followRedirects) {
     return this;
   }
 
+  /**
+   * Allows to close http connection or keep it alive.
+   * <p>
+   * By default, JMeter sends `Connection: keep-alive` header to enable persistent connection.
+   * To change default behavior and close every connection
+   * http client should send `Connection: close` header.
+   * This method allows enabling/disabling such behavior.
+   *
+   * @param useKeepAlive sets either to enable or disable persistent connection
+   * @return the sampler for further configuration or usage.
+   * @since 1.30
+   */
+  public DslHttpSampler useKeepAlive(boolean useKeepAlive) {
+    this.useKeepAlive = useKeepAlive;
+    return this;
+  }
+
   /**
    * Allows enabling automatic download of HTML embedded resources (images, iframes, etc).
    * <p>
@@ -422,7 +440,9 @@ with solved entries (like FunctionProperty)
     if (followRedirects != null) {
       elem.setFollowRedirects(followRedirects);
     }
-    elem.setUseKeepAlive(true);
+    if (useKeepAlive != null) {
+      elem.setUseKeepAlive(useKeepAlive);
+    }
     HttpElementHelper.modifyTestElementEmbeddedResources(elem, downloadEmbeddedResources,
         embeddedResourcesMatchRegex, embeddedResourcesNotMatchRegex);
     if (clientImpl != null) {
@@ -445,6 +465,13 @@ public HashTree buildTreeUnder(HashTree parent, BuildTreeContext context) {
        */
       DslHttpDefaults.addPendingFollowRedirectsElement(element, context);
     }
+    if (useKeepAlive == null) {
+      /*
+      Not setting keep alive default value in buildTestElement and differing it, allows for
+      httpDefaults to define connection behavior for elements that have not specified a value.
+       */
+      DslHttpDefaults.addPendingUseKeepAliveElement(element, context);
+    }
     return ret;
   }
 
@@ -511,6 +538,7 @@ protected MethodCall buildBaseHttpMethodCall(MethodParam name, MethodParam url,
     protected void chainAdditionalOptions(MethodCall ret, TestElementParamBuilder paramBuilder) {
       HttpElementHelper.chainEncodingToMethodCall(ret, paramBuilder);
       ret.chain("followRedirects", buildFollowRedirectsParam(paramBuilder));
+      ret.chain("useKeepAlive", buildUseKeepAliveParam(paramBuilder));
       HttpElementHelper.chainEmbeddedResourcesOptionsToMethodCall(ret, paramBuilder);
       HttpElementHelper.chainClientImplToMethodCall(ret, paramBuilder);
     }
@@ -599,6 +627,10 @@ private MethodParam buildFollowRedirectsParam(TestElementParamBuilder paramBuild
       }
     }
 
+    private MethodParam buildUseKeepAliveParam(TestElementParamBuilder paramBuilder) {
+      return paramBuilder.boolParam(HTTPSamplerBase.USE_KEEPALIVE, true);
+    }
+
     private static class HttpMethodParam extends StringParam {
 
       private static final Map<String, String> CONSTANT_METHODS = findConstantNamesMap(
diff --git a/jmeter-java-dsl/src/test/java/us/abstracta/jmeter/javadsl/http/DslHttpDefaultsTest.java b/jmeter-java-dsl/src/test/java/us/abstracta/jmeter/javadsl/http/DslHttpDefaultsTest.java
@@ -7,6 +7,8 @@
 import static com.github.tomakehurst.wiremock.client.WireMock.stubFor;
 import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
 import static com.github.tomakehurst.wiremock.client.WireMock.verify;
+import static com.github.tomakehurst.wiremock.client.WireMock.anyUrl;
+import static com.github.tomakehurst.wiremock.client.WireMock.equalTo;
 import static org.assertj.core.api.Assertions.assertThat;
 import static us.abstracta.jmeter.javadsl.JmeterDsl.httpDefaults;
 import static us.abstracta.jmeter.javadsl.JmeterDsl.httpSampler;
@@ -205,6 +207,19 @@ private void setupMockedRedirectionTo(String redirectPath) {
             .withHeader("Location", wiremockUri + redirectPath)));
   }
 
+  @Test
+  public void shouldNotSendConnectionKeepAliveWhenDisabledInDefaultsAndNotSettingInSampler()
+          throws Exception {
+    testPlan(
+       httpDefaults()
+           .useKeepAlive(false),
+       threadGroup(1, 1,
+           httpSampler(wiremockUri)
+       )
+    ).run();
+    verify(getRequestedFor(anyUrl()).withHeader("Connection", equalTo("close")));
+  }
+
   @Test
   public void shouldShowInGuiWhenShowInGui() {
     Robot robot = BasicRobot.robotWithNewAwtHierarchy();
diff --git a/jmeter-java-dsl/src/test/java/us/abstracta/jmeter/javadsl/http/DslHttpSamplerTest.java b/jmeter-java-dsl/src/test/java/us/abstracta/jmeter/javadsl/http/DslHttpSamplerTest.java
@@ -112,6 +112,18 @@ public void shouldNotFollowRedirectsWhenHttpSamplerWithDisabledFollowRedirects()
     verify(0, getRequestedFor(urlPathEqualTo(REDIRECT_PATH)));
   }
 
+  @Test
+  public void shouldNotSendConnectionKeepAliveWhenHttpSamplerWithDisabledKeepAlive()
+      throws Exception {
+    testPlan(
+        threadGroup(1, 1,
+            httpSampler(wiremockUri)
+                .useKeepAlive(false)
+        )
+    ).run();
+    verify(getRequestedFor(anyUrl()).withHeader("Connection", equalTo("close")));
+  }
+
   @Test
   public void shouldSendHeadersWhenHttpSamplerWithHeaders() throws Exception {
     testPlan(
@@ -646,6 +658,15 @@ public DslTestPlan testPlanWithHttpGetNotFollowingRedirects() {
       );
     }
 
+    public DslTestPlan testPlanWithHttpGetNotUsingKeepAlive() {
+      return testPlan(
+          threadGroup(1, 1,
+              httpSampler("http://localhost")
+                  .useKeepAlive(false)
+          )
+      );
+    }
+
     public DslTestPlan testPlanWithHttpGetAndEmbeddedResourcesDownload() {
       return testPlan(
           threadGroup(1, 1,
