• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

box / box-java-sdk / #7747

18 Nov 2026 05:48PM UTC coverage: 33.823% (+0.005%) from 33.818%
#7747

push

github

web-flow
chore: release version 10.22.0

1 of 1 new or added line in 1 file covered. (100.0%)

8 existing lines in 4 files now uncovered.

21964 of 64938 relevant lines covered (33.82%)

0.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0
/src/main/java/com/box/sdkgen/networking/defaultnetworkclient/DefaultNetworkClient.java
1
package com.box.sdkgen.networking.defaultnetworkclient;
2

3
import static com.box.sdkgen.serialization.json.JsonManager.jsonToSerializedData;
4
import static com.box.sdkgen.serialization.json.JsonManager.sdToJson;
5
import static com.box.sdkgen.serialization.json.JsonManager.sdToUrlParams;
6
import static java.util.Collections.singletonList;
7
import static okhttp3.ConnectionSpec.MODERN_TLS;
8

9
import com.box.sdkgen.box.errors.BoxSDKError;
10
import com.box.sdkgen.networking.fetchoptions.FetchOptions;
11
import com.box.sdkgen.networking.fetchoptions.MultipartItem;
12
import com.box.sdkgen.networking.fetchoptions.ResponseFormat;
13
import com.box.sdkgen.networking.fetchresponse.FetchResponse;
14
import com.box.sdkgen.networking.inputstreamrequestbody.InputStreamRequestBody;
15
import com.box.sdkgen.networking.network.NetworkSession;
16
import com.box.sdkgen.networking.networkclient.NetworkClient;
17
import java.io.IOException;
18
import java.io.InputStream;
19
import java.util.Locale;
20
import java.util.Map;
21
import java.util.Objects;
22
import java.util.TreeMap;
23
import java.util.concurrent.TimeUnit;
24
import java.util.stream.Collectors;
25
import okhttp3.Call;
26
import okhttp3.Headers;
27
import okhttp3.HttpUrl;
28
import okhttp3.MediaType;
29
import okhttp3.MultipartBody;
30
import okhttp3.OkHttpClient;
31
import okhttp3.Request;
32
import okhttp3.RequestBody;
33
import okhttp3.Response;
34

35
public class DefaultNetworkClient implements NetworkClient {
36

37
  protected OkHttpClient httpClient;
38

39
  public DefaultNetworkClient(OkHttpClient httpClient) {
×
40
    this.httpClient = httpClient;
×
41
  }
×
42

43
  public DefaultNetworkClient() {
×
44
    httpClient = getDefaultOkHttpClientBuilder().build();
×
45
  }
×
46

47
  public FetchResponse fetch(FetchOptions options) {
48
    try {
49
      return fetchWithRetries(options);
×
50
    } finally {
51
      closeFileStreams(options);
×
52
    }
53
  }
54

55
  private FetchResponse fetchWithRetries(FetchOptions options) {
UNCOV
56
    NetworkSession networkSession =
×
57
        options.getNetworkSession() == null ? new NetworkSession() : options.getNetworkSession();
×
58

59
    FetchOptions fetchOptions =
×
60
        networkSession.getInterceptors().stream()
×
61
            .reduce(
×
62
                options,
63
                (modifiedOptions, interceptor) -> interceptor.beforeRequest(modifiedOptions),
×
64
                (o1, o2) -> o2);
×
65

66
    boolean authenticationNeeded = false;
×
67
    Request request;
68
    RequestBody body = prepareRequestBody(fetchOptions);
×
69
    FetchResponse fetchResponse = null;
×
70
    Exception exceptionThrown = null;
×
71

72
    int attemptNumber = 1;
×
73
    int numberOfRetriesOnException = 0;
×
74
    int attemptForRetry = 0;
×
75
    boolean shouldRetry = false;
×
76

77
    while (true) {
78
      request = prepareRequest(fetchOptions, body, authenticationNeeded, networkSession);
×
79

80
      Response response = null;
×
81
      try {
82
        response = executeOnClient(request);
×
83

84
        Map<String, String> headersMap =
×
85
            response.headers().toMultimap().entrySet().stream()
×
86
                .collect(
×
87
                    Collectors.toMap(
×
88
                        Map.Entry::getKey,
89
                        e -> e.getValue().get(0),
×
90
                        (existing, replacement) -> existing,
×
91
                        () -> new TreeMap<>(String.CASE_INSENSITIVE_ORDER)));
×
92

UNCOV
93
        String responseUrl =
×
94
            response.networkResponse() != null
×
95
                ? response.networkResponse().request().url().toString()
×
96
                : response.request().url().toString();
×
97

98
        attemptForRetry = attemptNumber;
×
UNCOV
99
        fetchResponse =
×
100
            Objects.equals(fetchOptions.getResponseFormat().getEnumValue(), ResponseFormat.BINARY)
×
101
                ? new FetchResponse.Builder(response.code(), headersMap)
×
102
                    .content(response.body().byteStream())
×
103
                    .url(responseUrl)
×
104
                    .build()
×
105
                : new FetchResponse.Builder(response.code(), headersMap)
×
106
                    .data(
×
107
                        response.body() != null
×
108
                            ? jsonToSerializedData(response.body().string())
×
109
                            : null)
110
                    .url(responseUrl)
×
111
                    .build();
×
112

113
        fetchResponse =
×
114
            networkSession.getInterceptors().stream()
×
115
                .reduce(
×
116
                    fetchResponse,
117
                    (modifiedResponse, interceptor) -> interceptor.afterRequest(modifiedResponse),
×
118
                    (o1, o2) -> o2);
×
119

120
      } catch (Exception e) {
×
121
        exceptionThrown = e;
×
122
        numberOfRetriesOnException++;
×
123
        attemptForRetry = numberOfRetriesOnException;
×
124
        fetchResponse = new FetchResponse.Builder(0, new TreeMap<>()).build();
×
125
        if (response != null) {
×
126
          response.close();
×
127
        }
128
      }
×
129

130
      shouldRetry =
×
131
          networkSession
132
              .getRetryStrategy()
×
133
              .shouldRetry(fetchOptions, fetchResponse, attemptForRetry);
×
134
      boolean isRetryable = canBeResent(body);
×
135

136
      if (shouldRetry && isRetryable) {
×
137
        double retryDelay =
×
138
            networkSession
139
                .getRetryStrategy()
×
140
                .retryAfter(fetchOptions, fetchResponse, attemptForRetry);
×
141
        if (retryDelay > 0) {
×
142
          try {
143
            TimeUnit.SECONDS.sleep((long) retryDelay);
×
144
          } catch (InterruptedException ie) {
×
145
            Thread.currentThread().interrupt();
×
146
            throw new BoxSDKError("Retry interrupted", ie);
×
147
          }
×
148
        }
149
        attemptNumber++;
×
150
        continue;
×
151
      }
152

153
      if (fetchResponse.getStatus() >= 300
×
154
          && fetchResponse.getStatus() < 400
×
155
          && fetchOptions.followRedirects) {
×
156
        if (!fetchResponse.getHeaders().containsKey("Location")) {
×
157
          throw new BoxSDKError(
×
158
              "Redirect response missing Location header for " + fetchOptions.getUrl());
×
159
        }
160
        return fetch(
×
161
            new FetchOptions.Builder(fetchResponse.getHeaders().get("Location"), "GET")
×
162
                .responseFormat(fetchOptions.getResponseFormat())
×
163
                .auth(fetchOptions.getAuth())
×
164
                .networkSession(networkSession)
×
165
                .build());
×
166
      }
167

168
      if (fetchResponse != null
×
169
          && fetchResponse.getStatus() >= 200
×
170
          && fetchResponse.getStatus() < 400) {
×
171
        return fetchResponse;
×
172
      }
173

174
      throwOnUnsuccessfulResponse(request, fetchResponse, exceptionThrown);
×
175
    }
×
176
  }
177

178
  private static Request prepareRequest(
179
      FetchOptions options,
180
      RequestBody body,
181
      boolean reauthenticate,
182
      NetworkSession networkSession) {
183
    Request.Builder requestBuilder = new Request.Builder().url(options.getUrl());
×
184
    Headers headers = prepareHeaders(options, reauthenticate, networkSession);
×
185
    HttpUrl url = prepareUrl(options);
×
186

187
    requestBuilder.headers(headers);
×
188
    requestBuilder.url(url);
×
189
    requestBuilder.method(options.getMethod().toUpperCase(Locale.ROOT), body);
×
190
    return requestBuilder.build();
×
191
  }
192

193
  private static Headers prepareHeaders(
194
      FetchOptions options, boolean reauthenticate, NetworkSession networkSession) {
195
    Headers.Builder headersBuilder = new Headers.Builder();
×
196

197
    networkSession.getAdditionalHeaders().forEach(headersBuilder::add);
×
198

199
    if (options.getHeaders() != null) {
×
200
      options.getHeaders().forEach(headersBuilder::add);
×
201
    }
202
    if (options.getAuth() != null) {
×
203
      if (reauthenticate) {
×
204
        options.getAuth().refreshToken(networkSession);
×
205
      }
206
      headersBuilder.add(
×
207
          "Authorization", options.getAuth().retrieveAuthorizationHeader(networkSession));
×
208
    }
209
    return headersBuilder.build();
×
210
  }
211

212
  private static HttpUrl prepareUrl(FetchOptions options) {
213

214
    HttpUrl baseUrl = HttpUrl.parse(options.getUrl());
×
215
    if (baseUrl == null) {
×
216
      throw new IllegalArgumentException("Invalid URL " + options.getUrl());
×
217
    }
218
    HttpUrl.Builder urlBuilder = baseUrl.newBuilder();
×
219
    if (options.getParams() != null) {
×
220
      options.getParams().forEach(urlBuilder::addQueryParameter);
×
221
    }
222
    return urlBuilder.build();
×
223
  }
224

225
  private static RequestBody prepareRequestBody(FetchOptions options) {
226
    if (options.getMethod().equalsIgnoreCase("GET")) {
×
227
      return null;
×
228
    }
229
    String contentType = options.getContentType();
×
230
    MediaType mediaType = MediaType.parse(contentType);
×
231
    switch (contentType) {
×
232
      case "application/json":
233
      case "application/json-patch+json":
234
        return options.getData() != null
×
235
            ? RequestBody.create(sdToJson(options.getData()), mediaType)
×
236
            : RequestBody.create("", mediaType);
×
237
      case "application/x-www-form-urlencoded":
238
        return options.getData() != null
×
239
            ? RequestBody.create(sdToUrlParams(options.getData()), mediaType)
×
240
            : RequestBody.create("", mediaType);
×
241
      case "multipart/form-data":
242
        MultipartBody.Builder bodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
×
243
        for (MultipartItem part : options.multipartData) {
×
244
          if (part.getData() != null) {
×
245
            bodyBuilder.addFormDataPart(part.getPartName(), sdToJson(part.getData()));
×
246
          } else {
247
            bodyBuilder.addFormDataPart(
×
248
                part.getPartName(),
×
249
                part.getFileName() != null ? part.getFileName() : "file",
×
250
                createMultipartRequestBody(part));
×
251
          }
252
        }
×
253
        return bodyBuilder.build();
×
254
      default:
255
        throw new IllegalArgumentException("Unsupported content type " + contentType);
×
256
    }
257
  }
258

259
  protected Call createNewCall(Request request) {
260
    return this.httpClient.newCall(request);
×
261
  }
262

263
  private Response executeOnClient(Request request) {
264
    try {
265
      return createNewCall(request).execute();
×
266
    } catch (IOException e) {
×
267
      throw new RuntimeException(e);
×
268
    }
269
  }
270

271
  private static void closeFileStreams(FetchOptions options) {
272
    if (options.getFileStream() != null) {
×
273
      closeQuietly(options.getFileStream());
×
274
    }
275
    if (options.getMultipartData() != null) {
×
276
      options.getMultipartData().stream()
×
277
          .map(MultipartItem::getFileStream)
×
278
          .filter(Objects::nonNull)
×
279
          .forEach(DefaultNetworkClient::closeQuietly);
×
280
    }
281
  }
×
282

283
  /** A failure to close a stream must not replace the result or the error of the request. */
284
  private static void closeQuietly(InputStream stream) {
285
    try {
286
      stream.close();
×
287
    } catch (IOException ignored) {
×
288
    }
×
289
  }
×
290

291
  private static boolean canBeResent(RequestBody body) {
292
    if (body instanceof MultipartBody) {
×
293
      return ((MultipartBody) body).parts().stream().allMatch(part -> canBeResent(part.body()));
×
294
    }
295
    return !(body instanceof InputStreamRequestBody)
×
296
        || ((InputStreamRequestBody) body).canBeResent();
×
297
  }
298

299
  public static RequestBody createMultipartRequestBody(MultipartItem part) {
UNCOV
300
    MediaType contentType =
×
301
        MediaType.parse(part.contentType != null ? part.contentType : "application/octet-stream");
×
302
    return new InputStreamRequestBody(part.getFileStream(), contentType);
×
303
  }
304

305
  public static OkHttpClient.Builder getDefaultOkHttpClientBuilder() {
306
    return new OkHttpClient.Builder()
×
307
        .followSslRedirects(true)
×
308
        .followRedirects(false)
×
309
        .connectionSpecs(singletonList(MODERN_TLS))
×
310
        .retryOnConnectionFailure(false);
×
311
  }
312

313
  private static void throwOnUnsuccessfulResponse(
314
      Request request, FetchResponse fetchResponse, Exception exceptionThrown) {
315
    if (fetchResponse == null) {
×
316
      throw new RuntimeException(exceptionThrown.getMessage(), exceptionThrown);
×
317
    }
318
    throw new RuntimeException(fetchResponse.getData().toString());
×
319
  }
320
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc