From d1b44507ca9a142cf5b4307c1f956f15e347899f Mon Sep 17 00:00:00 2001 From: box-sdk-build Date: Mon, 16 Nov 2026 09:44:51 -0800 Subject: [PATCH 1/2] fix(SDK-6627): Avoid duplicate `jti` errors by signing a new JWT assertion on token request retries (box/box-codegen#1001) --- .codegen.json | 2 +- docs/sdkgen/client.md | 2 + .../test/BoxNetworkClientRetryTest.java | 388 ++++++++++++++++++ .../box/sdkgen/box/jwtauth/BoxJWTAuth.java | 58 ++- .../jwtauth/JwtAccessTokenDataFactory.java | 101 +++++ .../sdkgen/internal/utils/UtilsManager.java | 2 +- .../boxnetworkclient/BoxNetworkClient.java | 46 ++- .../networking/fetchoptions/FetchOptions.java | 17 + .../fetchoptions/RequestDataFactory.java | 9 + 9 files changed, 582 insertions(+), 43 deletions(-) create mode 100644 src/intTest/java/com/box/sdkgen/test/BoxNetworkClientRetryTest.java create mode 100644 src/main/java/com/box/sdkgen/box/jwtauth/JwtAccessTokenDataFactory.java create mode 100644 src/main/java/com/box/sdkgen/networking/fetchoptions/RequestDataFactory.java diff --git a/.codegen.json b/.codegen.json index b488f3bb6..06dd81ce5 100644 --- a/.codegen.json +++ b/.codegen.json @@ -1 +1 @@ -{ "engineHash": "0eab570", "specHash": "7f8494a", "version": "5.20.0" } +{ "engineHash": "6772894", "specHash": "7f8494a", "version": "5.20.0" } diff --git a/docs/sdkgen/client.md b/docs/sdkgen/client.md index c78e51b7e..c87258e57 100644 --- a/docs/sdkgen/client.md +++ b/docs/sdkgen/client.md @@ -29,6 +29,8 @@ This method allows you to make any HTTP request to the Box API. It will automati network configuration settings from the client. The method accepts a `FetchOptions` object as an argument and returns a `FetchResponse` object. +For request bodies that cannot be safely replayed, such as a JWT assertion with a one-time `jti`, `FetchOptions` also accepts `dataFactory`. `dataFactory.create()` is called on the first attempt when `data` is not set and on each retry so each retry can send a fresh body. + ## JSON request The following example demonstrates how to make a custom POST request to create a new folder in the root folder. diff --git a/src/intTest/java/com/box/sdkgen/test/BoxNetworkClientRetryTest.java b/src/intTest/java/com/box/sdkgen/test/BoxNetworkClientRetryTest.java new file mode 100644 index 000000000..13dc52822 --- /dev/null +++ b/src/intTest/java/com/box/sdkgen/test/BoxNetworkClientRetryTest.java @@ -0,0 +1,388 @@ +package com.box.sdkgen.test; + +import static com.box.sdkgen.serialization.json.JsonManager.jsonToSerializedData; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.box.sdkgen.box.jwtauth.BoxJWTAuth; +import com.box.sdkgen.box.jwtauth.JWTConfig; +import com.box.sdkgen.internal.utils.PrivateKeyDecryptor; +import com.box.sdkgen.networking.baseurls.BaseUrls; +import com.box.sdkgen.networking.boxnetworkclient.BoxNetworkClient; +import com.box.sdkgen.networking.fetchoptions.FetchOptions; +import com.box.sdkgen.networking.fetchoptions.RequestDataFactory; +import com.box.sdkgen.networking.fetchoptions.ResponseFormat; +import com.box.sdkgen.networking.fetchresponse.FetchResponse; +import com.box.sdkgen.networking.interceptors.Interceptor; +import com.box.sdkgen.networking.network.NetworkSession; +import com.box.sdkgen.networking.retries.RetryStrategy; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.nio.charset.StandardCharsets; +import java.security.KeyPair; +import java.security.KeyPairGenerator; +import java.security.PrivateKey; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import java.util.Objects; +import java.util.concurrent.atomic.AtomicBoolean; +import okhttp3.ConnectionSpec; +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.MockWebServer; +import okhttp3.mockwebserver.RecordedRequest; +import org.junit.jupiter.api.Test; + +public class BoxNetworkClientRetryTest { + + private final ObjectMapper objectMapper = new ObjectMapper(); + + @Test + public void testNetworkExceptionRetryRegeneratesRequestData() throws Exception { + try (MockWebServer server = new MockWebServer()) { + server.enqueue(jsonResponse(200, "{\"ok\":true}")); + server.start(); + + List bodies = new ArrayList<>(); + CountingDataFactory dataFactory = new CountingDataFactory(); + testNetworkClientThatFailsFirstRequest(bodies) + .fetch( + baseOptions(server.url("/").toString(), jsonToSerializedData("{\"attempt\":\"D1\"}")) + .dataFactory(dataFactory) + .networkSession( + new NetworkSession() + .withRetryStrategy( + retryWhen( + (options, response, attempt) -> + response.getStatus() == 0 && attempt < 2))) + .build()); + + assertEquals(Arrays.asList("attempt=D1", "attempt=D2"), bodies); + assertEquals(1, dataFactory.calls); + } + } + + @Test + public void test500RetryRegeneratesRequestData() throws Exception { + try (MockWebServer server = new MockWebServer()) { + server.enqueue(jsonResponse(500, "{\"error\":\"retry\"}")); + server.enqueue(jsonResponse(200, "{\"ok\":true}")); + server.start(); + + CountingDataFactory dataFactory = new CountingDataFactory(); + testNetworkClient() + .fetch( + baseOptions(server.url("/").toString(), jsonToSerializedData("{\"attempt\":\"D1\"}")) + .dataFactory(dataFactory) + .networkSession( + new NetworkSession() + .withRetryStrategy( + retryWhen( + (options, response, attempt) -> response.getStatus() == 500))) + .build()); + + assertEquals("attempt=D1", takeBody(server)); + assertEquals("attempt=D2", takeBody(server)); + assertEquals(1, dataFactory.calls); + } + } + + @Test + public void testRetryStrategyReceivesRegeneratedRequestData() throws Exception { + try (MockWebServer server = new MockWebServer()) { + server.enqueue(jsonResponse(500, "{\"error\":\"retry\"}")); + server.enqueue(jsonResponse(200, "{\"ok\":true}")); + server.start(); + + List retryData = new ArrayList<>(); + CountingDataFactory dataFactory = new CountingDataFactory(); + testNetworkClient() + .fetch( + baseOptions(server.url("/").toString(), jsonToSerializedData("{\"attempt\":\"D1\"}")) + .dataFactory(dataFactory) + .networkSession( + new NetworkSession() + .withRetryStrategy( + retryWhen( + (options, response, attempt) -> { + retryData.add(options.getData().get("attempt").asText()); + return response.getStatus() == 500; + }))) + .build()); + + assertEquals(Arrays.asList("D1", "D2"), retryData); + } + } + + @Test + public void testInterceptorRunsOnEachRetryWithRebuiltData() throws Exception { + try (MockWebServer server = new MockWebServer()) { + server.enqueue(jsonResponse(500, "{\"error\":\"retry\"}")); + server.enqueue(jsonResponse(200, "{\"ok\":true}")); + server.start(); + + List interceptorData = new ArrayList<>(); + NetworkSession networkSession = + new NetworkSession() + .withInterceptors( + Arrays.asList( + new Interceptor() { + @Override + public FetchOptions beforeRequest(FetchOptions options) { + interceptorData.add(options.getData().get("attempt").asText()); + return options; + } + + @Override + public FetchResponse afterRequest(FetchResponse response) { + return response; + } + })) + .withRetryStrategy( + retryWhen((options, response, attempt) -> response.getStatus() == 500)); + + CountingDataFactory dataFactory = new CountingDataFactory(); + testNetworkClient() + .fetch( + baseOptions(server.url("/").toString(), jsonToSerializedData("{\"attempt\":\"D1\"}")) + .dataFactory(dataFactory) + .networkSession(networkSession) + .build()); + + assertEquals(Arrays.asList("D1", "D2"), interceptorData); + assertEquals(1, dataFactory.calls); + } + } + + @Test + public void testRetryWithoutDataFactoryResendsSameRequestData() throws Exception { + try (MockWebServer server = new MockWebServer()) { + server.enqueue(jsonResponse(500, "{\"error\":\"retry\"}")); + server.enqueue(jsonResponse(200, "{\"ok\":true}")); + server.start(); + + testNetworkClient() + .fetch( + baseOptions(server.url("/").toString(), jsonToSerializedData("{\"attempt\":\"D1\"}")) + .networkSession( + new NetworkSession() + .withRetryStrategy( + retryWhen( + (options, response, attempt) -> response.getStatus() == 500))) + .build()); + + assertEquals("attempt=D1", takeBody(server)); + assertEquals("attempt=D1", takeBody(server)); + } + } + + @Test + public void testWithDataCopiesFetchOptionsExceptData() throws Exception { + RequestDataFactory dataFactory = new CountingDataFactory(); + NetworkSession networkSession = new NetworkSession(); + FetchOptions options = + baseOptions("https://example.com", jsonToSerializedData("{\"attempt\":\"D1\"}")) + .dataFactory(dataFactory) + .fileStream(new ByteArrayInputStream("file".getBytes(StandardCharsets.UTF_8))) + .responseFormat(ResponseFormat.JSON) + .networkSession(networkSession) + .followRedirects(false) + .build(); + + Method withData = + BoxNetworkClient.class.getDeclaredMethod("withData", FetchOptions.class, JsonNode.class); + withData.setAccessible(true); + FetchOptions copied = + (FetchOptions) withData.invoke(null, options, jsonToSerializedData("{\"attempt\":\"D2\"}")); + + for (Field field : FetchOptions.class.getDeclaredFields()) { + field.setAccessible(true); + if (field.getName().equals("data")) { + assertEquals("D2", ((JsonNode) field.get(copied)).get("attempt").asText()); + } else { + assertEquals(field.get(options), field.get(copied), "FetchOptions." + field.getName()); + } + } + } + + @Test + public void testBoxJWTAuthRegeneratesAssertionOnRetry() throws Exception { + try (MockWebServer server = new MockWebServer()) { + server.enqueue(jsonResponse(500, "{\"error\":\"retry\"}")); + server.enqueue( + jsonResponse( + 200, "{\"access_token\":\"token\",\"expires_in\":3600,\"token_type\":\"bearer\"}")); + server.start(); + + KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA"); + generator.initialize(2048); + KeyPair keyPair = generator.generateKeyPair(); + JWTConfig config = + new JWTConfig.Builder( + "client-id", "client-secret", "jwt-key-id", "unused-private-key", "passphrase") + .enterpriseId("enterprise-id") + .privateKeyDecryptor(new FixedPrivateKeyDecryptor(keyPair.getPrivate())) + .build(); + + new BoxJWTAuth(config) + .refreshToken( + new NetworkSession() + .withCustomBaseUrls( + new BaseUrls.Builder() + .baseUrl(server.url("").toString().replaceAll("/$", "")) + .uploadUrl(server.url("").toString()) + .oauth2Url(server.url("").toString()) + .build()) + .withNetworkClient(testNetworkClient()) + .withRetryStrategy( + new RetryStrategy() { + @Override + public boolean shouldRetry( + FetchOptions options, FetchResponse response, int attemptNumber) { + return response.getStatus() == 500; + } + + @Override + public double retryAfter( + FetchOptions options, FetchResponse response, int attemptNumber) { + return 1; + } + })); + + JwtPayload firstPayload = decodePayload(assertionFrom(takeBody(server))); + JwtPayload secondPayload = decodePayload(assertionFrom(takeBody(server))); + assertNotEquals(firstPayload.jti, secondPayload.jti); + assertTrue(secondPayload.exp > firstPayload.exp); + } + } + + private FetchOptions.Builder baseOptions(String url, JsonNode data) { + return new FetchOptions.Builder(url, "POST") + .contentType("application/x-www-form-urlencoded") + .responseFormat(ResponseFormat.JSON) + .data(data); + } + + private MockResponse jsonResponse(int status, String body) { + return new MockResponse() + .setResponseCode(status) + .setHeader("Content-Type", "application/json") + .setHeader("Retry-After", "0") + .setBody(body); + } + + private BoxNetworkClient testNetworkClient() { + return new BoxNetworkClient( + new OkHttpClient.Builder() + .connectionSpecs(Arrays.asList(ConnectionSpec.CLEARTEXT)) + .followRedirects(false) + .retryOnConnectionFailure(false) + .build()); + } + + private BoxNetworkClient testNetworkClientThatFailsFirstRequest(List bodies) { + AtomicBoolean firstRequest = new AtomicBoolean(true); + return new BoxNetworkClient( + new OkHttpClient.Builder() + .connectionSpecs(Arrays.asList(ConnectionSpec.CLEARTEXT)) + .followRedirects(false) + .retryOnConnectionFailure(false) + .addInterceptor( + chain -> { + Request request = chain.request(); + bodies.add(requestBodyToString(request)); + if (firstRequest.getAndSet(false)) { + throw new IOException("Simulated network exception"); + } + return chain.proceed(request); + }) + .build()); + } + + private String requestBodyToString(Request request) throws IOException { + if (request.body() == null) { + return ""; + } + okio.Buffer buffer = new okio.Buffer(); + request.body().writeTo(buffer); + return buffer.readUtf8(); + } + + private String takeBody(MockWebServer server) throws Exception { + RecordedRequest request = server.takeRequest(); + return request.getBody().readUtf8(); + } + + private RetryStrategy retryWhen(RetryPredicate predicate) { + return new RetryStrategy() { + @Override + public boolean shouldRetry(FetchOptions options, FetchResponse response, int attemptNumber) { + return predicate.shouldRetry(options, response, attemptNumber); + } + + @Override + public double retryAfter(FetchOptions options, FetchResponse response, int attemptNumber) { + return 0; + } + }; + } + + private String assertionFrom(String body) throws java.io.UnsupportedEncodingException { + for (String part : body.split("&")) { + String[] keyValue = part.split("=", 2); + if (keyValue.length == 2 && Objects.equals(keyValue[0], "assertion")) { + return java.net.URLDecoder.decode(keyValue[1], StandardCharsets.UTF_8.name()); + } + } + throw new AssertionError("Missing JWT assertion"); + } + + private JwtPayload decodePayload(String assertion) throws Exception { + String[] parts = assertion.split("\\."); + assertEquals(3, parts.length); + byte[] payload = Base64.getUrlDecoder().decode(parts[1]); + return objectMapper.readValue(payload, JwtPayload.class); + } + + private interface RetryPredicate { + boolean shouldRetry(FetchOptions options, FetchResponse response, int attemptNumber); + } + + private static class CountingDataFactory implements RequestDataFactory { + int calls = 0; + + @Override + public JsonNode create() { + calls += 1; + return jsonToSerializedData("{\"attempt\":\"D" + (calls + 1) + "\"}"); + } + } + + private static class FixedPrivateKeyDecryptor implements PrivateKeyDecryptor { + private final PrivateKey privateKey; + + FixedPrivateKeyDecryptor(PrivateKey privateKey) { + this.privateKey = privateKey; + } + + @Override + public PrivateKey decryptPrivateKey(String encryptedPrivateKey, String passphrase) { + return privateKey; + } + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static class JwtPayload { + public String jti; + public long exp; + } +} diff --git a/src/main/java/com/box/sdkgen/box/jwtauth/BoxJWTAuth.java b/src/main/java/com/box/sdkgen/box/jwtauth/BoxJWTAuth.java index edb1637a5..d306e5de2 100644 --- a/src/main/java/com/box/sdkgen/box/jwtauth/BoxJWTAuth.java +++ b/src/main/java/com/box/sdkgen/box/jwtauth/BoxJWTAuth.java @@ -1,27 +1,23 @@ package com.box.sdkgen.box.jwtauth; -import static com.box.sdkgen.internal.utils.UtilsManager.createJwtAssertion; -import static com.box.sdkgen.internal.utils.UtilsManager.entryOf; -import static com.box.sdkgen.internal.utils.UtilsManager.getEpochTimeInSeconds; -import static com.box.sdkgen.internal.utils.UtilsManager.getUuid; import static com.box.sdkgen.internal.utils.UtilsManager.isBrowser; -import static com.box.sdkgen.internal.utils.UtilsManager.mapOf; import com.box.sdkgen.box.errors.BoxSDKError; import com.box.sdkgen.box.tokenstorage.InMemoryTokenStorage; import com.box.sdkgen.box.tokenstorage.TokenStorage; -import com.box.sdkgen.internal.utils.JwtKey; -import com.box.sdkgen.internal.utils.JwtSignOptions; import com.box.sdkgen.managers.authorization.AuthorizationManager; import com.box.sdkgen.networking.auth.Authentication; +import com.box.sdkgen.networking.fetchoptions.FetchOptions; +import com.box.sdkgen.networking.fetchoptions.ResponseFormat; +import com.box.sdkgen.networking.fetchresponse.FetchResponse; import com.box.sdkgen.networking.network.NetworkSession; import com.box.sdkgen.schemas.accesstoken.AccessToken; import com.box.sdkgen.schemas.postoauth2revoke.PostOAuth2Revoke; import com.box.sdkgen.schemas.postoauth2token.PostOAuth2Token; import com.box.sdkgen.schemas.postoauth2token.PostOAuth2TokenGrantTypeField; import com.box.sdkgen.schemas.postoauth2token.PostOAuth2TokenSubjectTokenTypeField; +import com.box.sdkgen.serialization.json.JsonManager; import java.util.List; -import java.util.Map; public class BoxJWTAuth implements Authentication { @@ -68,33 +64,27 @@ public AccessToken refreshToken(NetworkSession networkSession) { if (isBrowser()) { throw new BoxSDKError("JWT auth is not supported in browser environment."); } - Map claims = - mapOf( - entryOf("exp", getEpochTimeInSeconds() + 30), - entryOf("box_sub_type", this.subjectType)); - JwtSignOptions jwtOptions = - new JwtSignOptions( - this.config.getAlgorithm(), - "https://api.box.com/oauth2/token", - this.config.getClientId(), - this.subjectId, - getUuid(), - this.config.getJwtKeyId(), - this.config.getPrivateKeyDecryptor()); - JwtKey jwtKey = new JwtKey(this.config.getPrivateKey(), this.config.getPrivateKeyPassphrase()); - String assertion = createJwtAssertion(claims, jwtKey, jwtOptions); - AuthorizationManager authManager = - new AuthorizationManager.Builder() - .networkSession((!(networkSession == null) ? networkSession : new NetworkSession())) + NetworkSession networkSessionToUse = + (!(networkSession == null) ? networkSession : new NetworkSession()); + JwtAccessTokenDataFactory dataFactory = + new JwtAccessTokenDataFactory.Builder(this.config) + .subjectId(this.subjectId) + .subjectType(this.subjectType) .build(); - AccessToken token = - authManager.requestAccessToken( - new PostOAuth2Token.Builder( - PostOAuth2TokenGrantTypeField.URN_IETF_PARAMS_OAUTH_GRANT_TYPE_JWT_BEARER) - .assertion(assertion) - .clientId(this.config.getClientId()) - .clientSecret(this.config.getClientSecret()) - .build()); + FetchResponse response = + networkSessionToUse + .getNetworkClient() + .fetch( + new FetchOptions.Builder( + String.join( + "", networkSessionToUse.getBaseUrls().getBaseUrl(), "/oauth2/token"), + "POST") + .dataFactory(dataFactory) + .contentType("application/x-www-form-urlencoded") + .responseFormat(ResponseFormat.JSON) + .networkSession(networkSessionToUse) + .build()); + AccessToken token = JsonManager.deserialize(response.getData(), AccessToken.class); this.tokenStorage.store(token); return token; } diff --git a/src/main/java/com/box/sdkgen/box/jwtauth/JwtAccessTokenDataFactory.java b/src/main/java/com/box/sdkgen/box/jwtauth/JwtAccessTokenDataFactory.java new file mode 100644 index 000000000..805784923 --- /dev/null +++ b/src/main/java/com/box/sdkgen/box/jwtauth/JwtAccessTokenDataFactory.java @@ -0,0 +1,101 @@ +package com.box.sdkgen.box.jwtauth; + +import static com.box.sdkgen.internal.utils.UtilsManager.createJwtAssertion; +import static com.box.sdkgen.internal.utils.UtilsManager.entryOf; +import static com.box.sdkgen.internal.utils.UtilsManager.getEpochTimeInSeconds; +import static com.box.sdkgen.internal.utils.UtilsManager.getUuid; +import static com.box.sdkgen.internal.utils.UtilsManager.mapOf; + +import com.box.sdkgen.internal.utils.JwtKey; +import com.box.sdkgen.internal.utils.JwtSignOptions; +import com.box.sdkgen.networking.fetchoptions.RequestDataFactory; +import com.box.sdkgen.schemas.postoauth2token.PostOAuth2Token; +import com.box.sdkgen.schemas.postoauth2token.PostOAuth2TokenGrantTypeField; +import com.box.sdkgen.serialization.json.JsonManager; +import com.fasterxml.jackson.databind.JsonNode; +import java.util.Map; + +/** + * Builds the body of a JWT bearer access token request. Each call signs a new assertion with a + * unique `jti`, so a retried request is not rejected as a replay. + */ +public class JwtAccessTokenDataFactory implements RequestDataFactory { + + /** JWT configuration used to sign the assertion */ + public final JWTConfig config; + + /** The ID of the user or enterprise to authenticate as */ + public String subjectId; + + /** The type of the subject ID, either 'user' or 'enterprise' */ + public String subjectType; + + public JwtAccessTokenDataFactory(JWTConfig config) { + this.config = config; + } + + protected JwtAccessTokenDataFactory(Builder builder) { + this.config = builder.config; + this.subjectId = builder.subjectId; + this.subjectType = builder.subjectType; + } + + /** Creates the access token request body with a newly signed JWT assertion. */ + @Override + public JsonNode create() { + Map claims = + mapOf( + entryOf("exp", getEpochTimeInSeconds() + 30), + entryOf("box_sub_type", this.subjectType)); + JwtSignOptions jwtOptions = + new JwtSignOptions( + this.config.getAlgorithm(), + "https://api.box.com/oauth2/token", + this.config.getClientId(), + this.subjectId, + getUuid(), + this.config.getJwtKeyId(), + this.config.getPrivateKeyDecryptor()); + JwtKey jwtKey = new JwtKey(this.config.getPrivateKey(), this.config.getPrivateKeyPassphrase()); + String assertion = createJwtAssertion(claims, jwtKey, jwtOptions); + PostOAuth2Token requestBody = + new PostOAuth2Token.Builder( + PostOAuth2TokenGrantTypeField.URN_IETF_PARAMS_OAUTH_GRANT_TYPE_JWT_BEARER) + .assertion(assertion) + .clientId(this.config.getClientId()) + .clientSecret(this.config.getClientSecret()) + .build(); + return JsonManager.serialize(requestBody); + } + + public JWTConfig getConfig() { + return config; + } + + public static class Builder { + + protected final JWTConfig config; + + protected String subjectId; + + protected String subjectType; + + public Builder(JWTConfig config) { + this.config = config; + } + + public Builder subjectId(String subjectId) { + this.subjectId = subjectId; + return this; + } + + public Builder subjectType(String subjectType) { + this.subjectType = subjectType; + return this; + } + + public JwtAccessTokenDataFactory build() { + return new JwtAccessTokenDataFactory(this); + } + } +} diff --git a/src/main/java/com/box/sdkgen/internal/utils/UtilsManager.java b/src/main/java/com/box/sdkgen/internal/utils/UtilsManager.java index a19d4f41a..d36a08824 100644 --- a/src/main/java/com/box/sdkgen/internal/utils/UtilsManager.java +++ b/src/main/java/com/box/sdkgen/internal/utils/UtilsManager.java @@ -268,7 +268,7 @@ public static String createJwtAssertion( jwtClaims.setSubject(jwtOptions.getSubject()); jwtClaims.setClaim("box_sub_type", claims.get("box_sub_type")); - jwtClaims.setGeneratedJwtId(64); + jwtClaims.setJwtId(jwtOptions.getJwtid()); JsonWebSignature jws = new JsonWebSignature(); jws.setPayload(jwtClaims.toJson()); diff --git a/src/main/java/com/box/sdkgen/networking/boxnetworkclient/BoxNetworkClient.java b/src/main/java/com/box/sdkgen/networking/boxnetworkclient/BoxNetworkClient.java index 208cd0603..dd203170e 100644 --- a/src/main/java/com/box/sdkgen/networking/boxnetworkclient/BoxNetworkClient.java +++ b/src/main/java/com/box/sdkgen/networking/boxnetworkclient/BoxNetworkClient.java @@ -135,13 +135,6 @@ public FetchResponse fetch(FetchOptions options) { NetworkSession networkSession = options.getNetworkSession() == null ? new NetworkSession() : options.getNetworkSession(); - FetchOptions fetchOptions = - networkSession.getInterceptors().stream() - .reduce( - options, - (modifiedOptions, interceptor) -> interceptor.beforeRequest(modifiedOptions), - (o1, o2) -> o2); - boolean authenticationNeeded = false; Request request; FetchResponse fetchResponse = new FetchResponse.Builder(0, new TreeMap<>()).build(); @@ -153,6 +146,20 @@ public FetchResponse fetch(FetchOptions options) { boolean shouldRetry = false; while (true) { + FetchOptions attemptOptions = + (attemptNumber > 1 || numberOfRetriesOnException > 0 || options.getData() == null) + && options.getDataFactory() != null + ? withData(options, options.getDataFactory().create()) + : options; + FetchOptions fetchOptions = applyInterceptors(attemptOptions, networkSession); + if (fetchOptions.getDataFactory() != null + && options.getDataFactory() == null + && (attemptNumber > 1 + || numberOfRetriesOnException > 0 + || fetchOptions.getData() == null)) { + fetchOptions = withData(fetchOptions, fetchOptions.getDataFactory().create()); + } + request = prepareRequest(fetchOptions, authenticationNeeded, networkSession); Response response = null; @@ -268,6 +275,31 @@ public FetchResponse fetch(FetchOptions options) { } } + private static FetchOptions applyInterceptors( + FetchOptions options, NetworkSession networkSession) { + return networkSession.getInterceptors().stream() + .reduce( + options, + (modifiedOptions, interceptor) -> interceptor.beforeRequest(modifiedOptions), + (o1, o2) -> o2); + } + + private static FetchOptions withData(FetchOptions options, JsonNode data) { + return new FetchOptions.Builder(options.getUrl(), options.getMethod()) + .params(options.getParams()) + .headers(options.getHeaders()) + .data(data) + .dataFactory(options.getDataFactory()) + .fileStream(options.getFileStream()) + .multipartData(options.getMultipartData()) + .contentType(options.getContentType()) + .responseFormat(options.getResponseFormat()) + .auth(options.getAuth()) + .networkSession(options.getNetworkSession()) + .followRedirects(options.getFollowRedirects()) + .build(); + } + private static Request prepareRequest( FetchOptions options, boolean reauthenticate, NetworkSession networkSession) { Request.Builder requestBuilder = new Request.Builder().url(options.getUrl()); diff --git a/src/main/java/com/box/sdkgen/networking/fetchoptions/FetchOptions.java b/src/main/java/com/box/sdkgen/networking/fetchoptions/FetchOptions.java index 6cf853922..bdc2f9a3d 100644 --- a/src/main/java/com/box/sdkgen/networking/fetchoptions/FetchOptions.java +++ b/src/main/java/com/box/sdkgen/networking/fetchoptions/FetchOptions.java @@ -25,6 +25,11 @@ public class FetchOptions { /** Request body of the request */ public JsonNode data; + /** + * Factory that builds a request body when `data` is not provided and rebuilds it for each retry. + */ + public RequestDataFactory dataFactory; + /** Stream data of the request */ public InputStream fileStream; @@ -63,6 +68,7 @@ protected FetchOptions(Builder builder) { this.params = builder.params; this.headers = builder.headers; this.data = builder.data; + this.dataFactory = builder.dataFactory; this.fileStream = builder.fileStream; this.multipartData = builder.multipartData; this.contentType = builder.contentType; @@ -92,6 +98,10 @@ public JsonNode getData() { return data; } + public RequestDataFactory getDataFactory() { + return dataFactory; + } + public InputStream getFileStream() { return fileStream; } @@ -132,6 +142,8 @@ public static class Builder { protected JsonNode data; + protected RequestDataFactory dataFactory; + protected InputStream fileStream; protected List multipartData; @@ -166,6 +178,11 @@ public Builder data(JsonNode data) { return this; } + public Builder dataFactory(RequestDataFactory dataFactory) { + this.dataFactory = dataFactory; + return this; + } + public Builder fileStream(InputStream fileStream) { this.fileStream = fileStream; return this; diff --git a/src/main/java/com/box/sdkgen/networking/fetchoptions/RequestDataFactory.java b/src/main/java/com/box/sdkgen/networking/fetchoptions/RequestDataFactory.java new file mode 100644 index 000000000..72975d17b --- /dev/null +++ b/src/main/java/com/box/sdkgen/networking/fetchoptions/RequestDataFactory.java @@ -0,0 +1,9 @@ +package com.box.sdkgen.networking.fetchoptions; + +import com.fasterxml.jackson.databind.JsonNode; + +public interface RequestDataFactory { + + /** Creates a new request body */ + JsonNode create(); +} From 0b371d7ff5780d4a3bae84d3e5ef0997946e981c Mon Sep 17 00:00:00 2001 From: lsocha Date: Wed, 18 Nov 2026 11:34:03 +0100 Subject: [PATCH 2/2] test: add okhttp mockwebserver test dependency --- build.gradle | 1 + 1 file changed, 1 insertion(+) diff --git a/build.gradle b/build.gradle index a0219178d..d84c70668 100644 --- a/build.gradle +++ b/build.gradle @@ -66,6 +66,7 @@ dependencies { testsCommonImplementation "org.hamcrest:hamcrest-library:2.2" testsCommonImplementation "org.mockito:mockito-core:4.8.0" testsCommonImplementation "org.slf4j:slf4j-nop:2.0.3" + testsCommonImplementation "com.squareup.okhttp3:mockwebserver:4.12.0" testRuntimeOnly "org.junit.vintage:junit-vintage-engine:5.10.0" testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.10.0" testImplementation "com.github.tomakehurst:wiremock:2.27.2"