Refactor Wave and Tower client to use lib-httpx library (#6354)

* Refactor Wave client to use lib-httpx library

- Replace manual HTTP retry logic with HxClient from io.seqera:lib-httpx:1.2.0
- Update RetryOpts to implement Retryable.Config interface from lib-retry
- Add multiplier field to RetryOpts for exponential backoff configuration
- Remove manual JWT token refresh logic in favor of HxClient built-in handling
- Update WaveClient to use HxClient.sendAsString() instead of raw HttpClient
- Remove redundant retry policy and HTTP response handling code
- Update tests to reflect API changes and remove obsolete HTTP retry test

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Bump httpx@1.3.0

Signed-off-by: Paolo Di Tommaso <paolo.ditommaso@gmail.com>

* Improve integration

Signed-off-by: Paolo Di Tommaso <paolo.ditommaso@gmail.com>

* Refactor Tower client to use lib-httpx library (#6357)

* Refactor Tower client to use lib-httpx library

- Replace manual HTTP retry logic with HxClient from io.seqera:lib-httpx
- Update TowerClient.sendHttpMessage() to use HxClient.sendAsString()
- Add HxClient configuration with retry settings, JWT token, and refresh token handling
- Update makeRequest() helper method to properly build HttpRequest objects with body content
- Remove redundant HTTP response handling code in favor of HxClient built-in functionality
- Update SimpleHttpClient to support content-type and authorization headers
- Update tests to reflect API changes
- Add comprehensive annotations to TowerRetryPolicy with default values
- Add Javadoc documentation to TowerRetryPolicy class explaining retry behavior
- Fix missing annotations in WaveConfig BuildOpts class (conda, compression, maxDuration)



Signed-off-by: Paolo Di Tommaso <paolo.ditommaso@gmail.com>
Signed-off-by: Ben Sherman <bentshermann@gmail.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Ben Sherman <bentshermann@gmail.com>

Author: 3 people

modules/nextflow/src/main/groovy/nextflow/util/SimpleHttpClient.groovy

@@ -32,6 +32,7 @@ import nextflow.BuildInfo
  *  Paolo Di Tommaso <paolo.ditommaso@gmail.com>
  */
 @Slf4j
+@Deprecated
 @CompileStatic
 class SimpleHttpClient {
 

modules/nf-commons/build.gradle

@@ -34,8 +34,8 @@ dependencies {
     api 'org.pf4j:pf4j:3.12.0'
     api 'org.pf4j:pf4j-update:2.3.0'
     api 'dev.failsafe:failsafe:3.1.0'
-    api 'io.seqera:lib-httpx:1.0.0'
-    api 'io.seqera:lib-retry:1.2.0'
+    api 'io.seqera:lib-httpx:2.0.0'
+    api 'io.seqera:lib-retry:2.0.0'
     // patch gson dependency required by pf4j
     api 'com.google.code.gson:gson:2.13.1'
     api 'io.seqera:npr-api:0.6.1'

modules/nf-commons/src/main/nextflow/plugin/HttpPluginRepository.groovy

@@ -44,7 +44,9 @@ class HttpPluginRepository implements PrefetchUpdateRepository {
         this.url = !url.toString().endsWith("/")
             ? URI.create(url.toString() + "/")
             : url
-        this.httpClient = HxClient.create(RetryConfig.config())
+        this.httpClient = HxClient.newBuilder()
+                .retryConfig(RetryConfig.config())
+                .build()
     }
 
     // NOTE ON PREFETCHING
@@ -135,7 +137,7 @@ class HttpPluginRepository implements PrefetchUpdateRepository {
             throw e
         }
         catch (Exception e) {
-            throw new PluginRuntimeException(e, "Unable to connect to ${uri}- cause: ${e.message}")
+            throw new PluginRuntimeException(e, "Unable to connect to ${uri} - cause: ${e.message}")
         }
     }
 

modules/nf-commons/src/main/nextflow/util/Duration.groovy

@@ -16,7 +16,11 @@
 
 package nextflow.util
 
+import java.time.temporal.ChronoUnit
 import java.time.temporal.Temporal
+import java.time.temporal.TemporalAmount
+import java.time.temporal.TemporalUnit
+import java.time.temporal.UnsupportedTemporalTypeException
 import java.util.concurrent.TimeUnit
 
 import groovy.transform.CompileStatic
@@ -32,7 +36,9 @@ import org.apache.commons.lang.time.DurationFormatUtils
 @Slf4j
 @CompileStatic
 @EqualsAndHashCode(includes = 'durationInMillis')
-class Duration implements IDuration, Comparable<Duration>, Serializable, Cloneable {
+class Duration implements IDuration, TemporalAmount, Comparable<Duration>, Serializable, Cloneable {
+
+    static private final List<TemporalUnit> SUPPORTED_UNITS = List.<TemporalUnit>of(ChronoUnit.DAYS, ChronoUnit.HOURS, ChronoUnit.MINUTES, ChronoUnit.SECONDS, ChronoUnit.MILLIS)
 
     static private final FORMAT = ~/^(\d+\.?\d*)\s*([a-zA-Z]+)/
 
@@ -365,4 +371,64 @@ class Duration implements IDuration, Comparable<Duration>, Serializable, Cloneab
         throw new IllegalArgumentException("Not a valid duration value: $right")
     }
 
+    // TemporalAmount interface methods
+    
+    /**
+     * Gets the value of the requested unit.
+     * 
+     * @param unit the TemporalUnit for which to return the value
+     * @return the long value of the unit
+     */
+    @Override
+    long get(TemporalUnit unit) {
+        if (unit == ChronoUnit.MILLIS) {
+            return durationInMillis
+        }
+        if (unit == ChronoUnit.SECONDS) {
+            return toSeconds()
+        }
+        if (unit == ChronoUnit.MINUTES) {
+            return toMinutes()
+        }
+        if (unit == ChronoUnit.HOURS) {
+            return toHours()
+        }
+        if (unit == ChronoUnit.DAYS) {
+            return toDays()
+        }
+        throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit)
+    }
+
+    /**
+     * Returns a list of units uniquely defining the value of this TemporalAmount.
+     * 
+     * @return a list of the supported ChronoUnits, not null
+     */
+    @Override
+    List<TemporalUnit> getUnits() {
+        return SUPPORTED_UNITS
+    }
+
+    /**
+     * Adds this amount to the specified temporal object.
+     * 
+     * @param temporal the temporal object to adjust, not null
+     * @return an object of the same type with the adjustment made, not null
+     */
+    @Override
+    Temporal addTo(Temporal temporal) {
+        return temporal.plus(durationInMillis, ChronoUnit.MILLIS)
+    }
+
+    /**
+     * Subtracts this amount from the specified temporal object.
+     * 
+     * @param temporal the temporal object to adjust, not null
+     * @return an object of the same type with the adjustment made, not null
+     */
+    @Override
+    Temporal subtractFrom(Temporal temporal) {
+        return temporal.minus(durationInMillis, ChronoUnit.MILLIS)
+    }
+
 }

modules/nf-commons/src/main/nextflow/util/RetryConfig.groovy

@@ -37,11 +37,11 @@ import nextflow.SysEnv
 @CompileStatic
 class RetryConfig implements Retryable.Config {
 
-    private final static Duration DEFAULT_DELAY = Duration.of('350ms')
-    private final static Duration DEFAULT_MAX_DELAY = Duration.of('90s')
-    private final static Integer DEFAULT_MAX_ATTEMPTS = 5
-    private final static Double DEFAULT_JITTER = 0.25
-    static final public double DEFAULT_MULTIPLIER = 2.0
+    public static final Duration DEFAULT_DELAY = Duration.of('350ms')
+    public static final Duration DEFAULT_MAX_DELAY = Duration.of('90s')
+    public static final Integer DEFAULT_MAX_ATTEMPTS = 5
+    public static final Double DEFAULT_JITTER = 0.25
+    public static final double DEFAULT_MULTIPLIER = 2.0
 
     private final static String ENV_PREFIX = 'NXF_RETRY_POLICY_'
 
@@ -68,17 +68,18 @@ class RetryConfig implements Retryable.Config {
             valueOf(config, 'multiplier', ENV_PREFIX, DEFAULT_MULTIPLIER, Double)
     }
 
-    java.time.Duration getDelay() {
-        return java.time.Duration.ofMillis(delay.toMillis())
+    Duration getDelay() {
+        return delay
     }
 
-    java.time.Duration getMaxDelay() {
-        return java.time.Duration.ofMillis(maxDelay.toMillis())
+    Duration getMaxDelay() {
+        return maxDelay
     }
 
     @Override
     int getMaxAttempts() {
-        return maxAttempts }
+        return maxAttempts
+    }
 
     @Override
     double getJitter() {

modules/nf-commons/src/test/nextflow/util/DurationTest.groovy

@@ -17,6 +17,9 @@
 package nextflow.util
 
 import java.time.Instant
+import java.time.LocalDateTime
+import java.time.temporal.ChronoUnit
+import java.time.temporal.UnsupportedTemporalTypeException
 
 import spock.lang.Specification
 import spock.lang.Unroll
@@ -196,5 +199,97 @@ class DurationTest extends Specification {
         Duration.between(start, end) == Duration.of('1sec')
     }
 
+    // TemporalAmount interface tests
+
+    def 'should get value for supported temporal units' () {
+        given:
+        def duration = new Duration('2d 3h 4m 5s 123ms')
+
+        expect:
+        duration.get(ChronoUnit.MILLIS) == duration.toMillis()
+        duration.get(ChronoUnit.SECONDS) == duration.toSeconds()
+        duration.get(ChronoUnit.MINUTES) == duration.toMinutes()
+        duration.get(ChronoUnit.HOURS) == duration.toHours()
+        duration.get(ChronoUnit.DAYS) == duration.toDays()
+    }
+
+    def 'should throw exception for unsupported temporal unit' () {
+        given:
+        def duration = new Duration('1h')
+
+        when:
+        duration.get(ChronoUnit.WEEKS)
+
+        then:
+        thrown(UnsupportedTemporalTypeException)
+    }
+
+    def 'should return list of supported units' () {
+        given:
+        def duration = new Duration('1h')
+
+        when:
+        def units = duration.getUnits()
+
+        then:
+        units.size() == 5
+        units.contains(ChronoUnit.DAYS)
+        units.contains(ChronoUnit.HOURS)
+        units.contains(ChronoUnit.MINUTES)
+        units.contains(ChronoUnit.SECONDS)
+        units.contains(ChronoUnit.MILLIS)
+        // Should be ordered from longest to shortest
+        units[0] == ChronoUnit.DAYS
+        units[4] == ChronoUnit.MILLIS
+    }
+
+    def 'should add duration to temporal' () {
+        given:
+        def duration = new Duration('2h 30m')
+        def dateTime = LocalDateTime.of(2023, 1, 1, 10, 0, 0)
+
+        when:
+        def result = duration.addTo(dateTime)
+
+        then:
+        result == LocalDateTime.of(2023, 1, 1, 12, 30, 0)
+    }
+
+    def 'should subtract duration from temporal' () {
+        given:
+        def duration = new Duration('1h 15m')
+        def dateTime = LocalDateTime.of(2023, 1, 1, 12, 30, 0)
+
+        when:
+        def result = duration.subtractFrom(dateTime)
+
+        then:
+        result == LocalDateTime.of(2023, 1, 1, 11, 15, 0)
+    }
+
+    def 'should add duration to instant' () {
+        given:
+        def duration = new Duration('5s')
+        def instant = Instant.ofEpochMilli(1000)
+
+        when:
+        def result = duration.addTo(instant)
+
+        then:
+        result == Instant.ofEpochMilli(6000)
+    }
+
+    def 'should subtract duration from instant' () {
+        given:
+        def duration = new Duration('2s')
+        def instant = Instant.ofEpochMilli(5000)
+
+        when:
+        def result = duration.subtractFrom(instant)
+
+        then:
+        result == Instant.ofEpochMilli(3000)
+    }
+
 
 }

modules/nf-commons/src/test/nextflow/util/RetryConfigTest.groovy

@@ -28,16 +28,16 @@ class RetryConfigTest extends Specification {
 
     def 'should create retry config' () {
         expect:
-        new RetryConfig().delay == java.time.Duration.ofMillis(350)
-        new RetryConfig().maxDelay == java.time.Duration.ofSeconds(90)
+        new RetryConfig().delay == Duration.of('350ms')
+        new RetryConfig().maxDelay == Duration.of('90s')
         new RetryConfig().maxAttempts == 5
         new RetryConfig().jitter == 0.25d
         new RetryConfig().multiplier == 2d
 
         and:
         new RetryConfig([maxAttempts: 20]).maxAttempts == 20
-        new RetryConfig([delay: '1s']).delay == java.time.Duration.ofSeconds(1)
-        new RetryConfig([maxDelay: '1m']).maxDelay == java.time.Duration.ofMinutes(1)
+        new RetryConfig([delay: '1s']).delay == Duration.of('1s')
+        new RetryConfig([maxDelay: '1m']).maxDelay == Duration.of('1m')
         new RetryConfig([jitter: '0.5']).jitter == 0.5d
         new RetryConfig([multiplier: '5']).multiplier == 5d
     }
@@ -53,8 +53,8 @@ class RetryConfigTest extends Specification {
         ])
 
         expect:
-        new RetryConfig().getDelay() == java.time.Duration.ofSeconds(10)
-        new RetryConfig().getMaxDelay() == java.time.Duration.ofSeconds(100)
+        new RetryConfig().getDelay() == Duration.of('10s')
+        new RetryConfig().getMaxDelay() == Duration.of('100s')
         new RetryConfig().getMaxAttempts() == 1000
         new RetryConfig().getJitter() == 10_000
         new RetryConfig().getMultiplier() == 90d

plugins/nf-tower/build.gradle

@@ -33,6 +33,7 @@ dependencies {
     compileOnly 'org.slf4j:slf4j-api:2.0.17'
     compileOnly 'org.pf4j:pf4j:3.12.0'
 
+    api 'io.seqera:lib-httpx:2.0.0'
     api "com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.15.0"
     api "com.fasterxml.jackson.core:jackson-databind:2.12.7.1"