Skip to content

Commit 5b46d7d

Browse files
committed
- improves header management for http response
1 parent bb326b2 commit 5b46d7d

7 files changed

Lines changed: 133 additions & 208 deletions

File tree

‎src/main/java/com/microsoft/graph/Util.java‎

Lines changed: 0 additions & 29 deletions
This file was deleted.

‎src/main/java/com/microsoft/graph/concurrency/ChunkedUploadResponseHandler.java‎

Lines changed: 14 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -25,10 +25,8 @@
2525
import com.google.common.io.ByteStreams;
2626

2727
import com.microsoft.graph.core.ClientException;
28-
import com.microsoft.graph.core.Constants;
2928
import com.microsoft.graph.http.GraphServiceException;
3029
import com.microsoft.graph.http.HttpResponseCode;
31-
import com.microsoft.graph.http.HttpResponseHeadersHelper;
3230
import com.microsoft.graph.http.IHttpRequest;
3331
import com.microsoft.graph.http.IStatefulResponseHandler;
3432
import com.microsoft.graph.logger.ILogger;
@@ -37,12 +35,12 @@
3735
import java.io.ByteArrayInputStream;
3836
import java.io.IOException;
3937
import java.io.InputStream;
40-
import java.util.Map;
4138

4239
import javax.annotation.Nonnull;
4340
import javax.annotation.Nullable;
4441

4542
import okhttp3.Response;
43+
import okhttp3.ResponseBody;
4644

4745
import static com.microsoft.graph.http.HttpResponseCode.HTTP_OK;
4846

@@ -53,8 +51,6 @@
5351
*/
5452
public class ChunkedUploadResponseHandler<UploadType>
5553
implements IStatefulResponseHandler<ChunkedUploadResult<UploadType>, UploadType> {
56-
57-
private final static HttpResponseHeadersHelper responseHeadersHelper = new HttpResponseHeadersHelper();
5854
/**
5955
* The expected deserialized upload type
6056
*/
@@ -107,25 +103,24 @@ public ChunkedUploadResult<UploadType> generateResult(
107103
response, logger));
108104
} else if (response.code() >= HTTP_OK
109105
&& response.code() < HttpResponseCode.HTTP_MULTIPLE_CHOICES) {
110-
final Map<String, String> headers = responseHeadersHelper.getResponseHeadersAsMapStringString(response);
111-
final String contentType = headers.get(Constants.CONTENT_TYPE_HEADER_NAME);
112-
final String location = headers.get("Location");
113-
if (contentType != null
114-
&& contentType.contains(Constants.JSON_CONTENT_TYPE)) {
115-
return parseJsonUploadResult(response, serializer, logger);
116-
} else if (location != null) {
117-
logger.logDebug("Upload session is completed (Outlook), uploaded item returned.");
118-
return new ChunkedUploadResult<>(this.deserializeTypeClass.getDeclaredConstructor().newInstance());
119-
} else {
120-
logger.logDebug("Upload session returned an unexpected response");
121-
}
106+
try(final ResponseBody body = response.body()) {
107+
final String location = response.headers().get("Location");
108+
if (body.contentType() != null && body.contentType().subtype().contains("json")) {
109+
return parseJsonUploadResult(body, serializer, logger);
110+
} else if (location != null) {
111+
logger.logDebug("Upload session is completed (Outlook), uploaded item returned.");
112+
return new ChunkedUploadResult<>(this.deserializeTypeClass.getDeclaredConstructor().newInstance());
113+
} else {
114+
logger.logDebug("Upload session returned an unexpected response");
115+
}
116+
}
122117
}
123118
return new ChunkedUploadResult<>(new ClientException("Received an unexpected response from the service, response code: " + response.code(), null));
124119
}
125120

126121
@Nonnull
127-
private ChunkedUploadResult<UploadType> parseJsonUploadResult(@Nonnull Response response, @Nonnull ISerializer serializer, @Nonnull ILogger logger) throws IOException {
128-
try (final InputStream in = response.body().byteStream()) {
122+
private ChunkedUploadResult<UploadType> parseJsonUploadResult(@Nonnull final ResponseBody responseBody, @Nonnull final ISerializer serializer, @Nonnull final ILogger logger) throws IOException {
123+
try (final InputStream in = responseBody.byteStream()) {
129124
final byte[] responseBytes = ByteStreams.toByteArray(in);
130125
final IUploadSession session = serializer.deserializeObject(new ByteArrayInputStream(responseBytes), uploadSessionClass);
131126

‎src/main/java/com/microsoft/graph/core/Constants.java‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -16,10 +16,6 @@ private Constants() {
1616
* The content type for JSON responses
1717
*/
1818
public static final String JSON_CONTENT_TYPE = "application/json";
19-
/**
20-
* The content type for TEXT responses
21-
*/
22-
public static final String TEXT_CONTENT_TYPE = "text/plain";
2319
/**
2420
* The binary content type header's value
2521
*/

‎src/main/java/com/microsoft/graph/http/CoreHttpProvider.java‎

Lines changed: 78 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -54,15 +54,13 @@
5454
import okhttp3.Request;
5555
import okhttp3.RequestBody;
5656
import okhttp3.Response;
57+
import okhttp3.ResponseBody;
5758
import okio.BufferedSink;
5859

59-
import static com.microsoft.graph.Util.closeQuietly;
60-
6160
/**
6261
* HTTP provider based off of OkHttp and msgraph-sdk-java-core library
6362
*/
6463
public class CoreHttpProvider implements IHttpProvider {
65-
private final static HttpResponseHeadersHelper responseHeadersHelper = new HttpResponseHeadersHelper();
6664
/**
6765
* The serializer
6866
*/
@@ -376,86 +374,88 @@ private <Result, Body, DeserializeType> Result processResponse(final Response re
376374
final Class<Result> resultClass,
377375
final Body serializable,
378376
final IStatefulResponseHandler<Result, DeserializeType> handler) {
379-
try {
380-
InputStream in = null;
381-
boolean isBinaryStreamInput = false;
377+
try(final ResponseBody body = response.body()) {
382378
try {
379+
InputStream in = null;
380+
boolean isBinaryStreamInput = false;
381+
try {
383382

384-
// Call being executed
383+
// Call being executed
385384

386385

387-
if (handler != null) {
388-
handler.configConnection(response);
389-
}
386+
if (handler != null) {
387+
handler.configConnection(response);
388+
}
390389

391-
logger.logDebug(String.format(Locale.ROOT, "Response code %d, %s",
392-
response.code(),
393-
response.message()));
390+
logger.logDebug(String.format(Locale.ROOT, "Response code %d, %s",
391+
response.code(),
392+
response.message()));
394393

395-
if (handler != null) {
396-
logger.logDebug("StatefulResponse is handling the HTTP response.");
397-
return handler.generateResult(
398-
request, response, this.serializer, this.logger);
399-
}
394+
if (handler != null) {
395+
logger.logDebug("StatefulResponse is handling the HTTP response.");
396+
return handler.generateResult(
397+
request, response, this.serializer, this.logger);
398+
}
400399

401-
if (response.code() >= HttpResponseCode.HTTP_CLIENT_ERROR) {
402-
logger.logDebug("Handling error response");
403-
in = response.body().byteStream();
404-
handleErrorResponse(request, serializable, response);
405-
}
400+
if (response.code() >= HttpResponseCode.HTTP_CLIENT_ERROR) {
401+
logger.logDebug("Handling error response");
402+
in = body.byteStream();
403+
handleErrorResponse(request, serializable, response);
404+
}
406405

407-
if (response.code() == HttpResponseCode.HTTP_NOBODY
408-
|| response.code() == HttpResponseCode.HTTP_NOT_MODIFIED) {
409-
logger.logDebug("Handling response with no body");
410-
return handleEmptyResponse(responseHeadersHelper.getResponseHeadersAsMapOfStringList(response), resultClass);
411-
}
406+
final Map<String, List<String>> responseHeaders = response.headers().toMultimap();
412407

413-
if (response.code() == HttpResponseCode.HTTP_ACCEPTED) {
414-
logger.logDebug("Handling accepted response");
415-
return handleEmptyResponse(responseHeadersHelper.getResponseHeadersAsMapOfStringList(response), resultClass);
416-
}
408+
if (response.code() == HttpResponseCode.HTTP_NOBODY
409+
|| response.code() == HttpResponseCode.HTTP_NOT_MODIFIED) {
410+
logger.logDebug("Handling response with no body");
411+
return handleEmptyResponse(responseHeaders, resultClass);
412+
}
417413

418-
in = new BufferedInputStream(response.body().byteStream());
419-
420-
final Map<String, String> headers = responseHeadersHelper.getResponseHeadersAsMapStringString(response);
421-
422-
if (response.body() == null || response.body().contentLength() == 0)
423-
return null;
424-
425-
final String contentType = headers.get(Constants.CONTENT_TYPE_HEADER_NAME);
426-
if (contentType != null && resultClass != InputStream.class &&
427-
contentType.contains(Constants.JSON_CONTENT_TYPE)) {
428-
logger.logDebug("Response json");
429-
return handleJsonResponse(in, responseHeadersHelper.getResponseHeadersAsMapOfStringList(response), resultClass);
430-
} else if (resultClass == InputStream.class) {
431-
logger.logDebug("Response binary");
432-
isBinaryStreamInput = true;
433-
return (Result) handleBinaryStream(in);
434-
} else if (contentType != null && resultClass != InputStream.class &&
435-
contentType.contains(Constants.TEXT_CONTENT_TYPE)) {
436-
return handleRawResponse(in, resultClass);
437-
} else {
438-
return null;
439-
}
440-
} finally {
441-
if (!isBinaryStreamInput) {
442-
try{
443-
if (in != null) in.close();
444-
}catch(IOException e) {
445-
logger.logError(e.getMessage(), e);
414+
if (response.code() == HttpResponseCode.HTTP_ACCEPTED) {
415+
logger.logDebug("Handling accepted response");
416+
return handleEmptyResponse(responseHeaders, resultClass);
417+
}
418+
419+
in = new BufferedInputStream(body.byteStream());
420+
421+
if (body == null || body.contentLength() == 0)
422+
return null;
423+
424+
if (body.contentType() != null && body.contentType().subtype().contains("json")
425+
&& resultClass != InputStream.class) {
426+
logger.logDebug("Response json");
427+
return handleJsonResponse(in, responseHeaders, resultClass);
428+
} else if (resultClass == InputStream.class) {
429+
logger.logDebug("Response binary");
430+
isBinaryStreamInput = true;
431+
return (Result) handleBinaryStream(in);
432+
} else if (body.contentType() != null && resultClass != InputStream.class &&
433+
body.contentType().type().contains("text") &&
434+
body.contentType().subtype().contains("plain")) {
435+
return handleRawResponse(in, resultClass);
436+
} else {
437+
return null;
438+
}
439+
} finally {
440+
if (!isBinaryStreamInput) {
441+
try{
442+
if (in != null) in.close();
443+
}catch(IOException e) {
444+
logger.logError(e.getMessage(), e);
445+
}
446+
if (response != null) response.close();
446447
}
447-
if (response != null) response.close();
448448
}
449+
} catch (final GraphServiceException ex) {
450+
final boolean shouldLogVerbosely = logger.getLoggingLevel() == LoggerLevel.DEBUG;
451+
logger.logError("Graph service exception " + ex.getMessage(shouldLogVerbosely), ex);
452+
throw ex;
453+
} catch (final Exception ex) {
454+
final ClientException clientException = new ClientException("Error during http request",
455+
ex);
456+
logger.logError("Error during http request", clientException);
457+
throw clientException;
449458
}
450-
} catch (final GraphServiceException ex) {
451-
final boolean shouldLogVerbosely = logger.getLoggingLevel() == LoggerLevel.DEBUG;
452-
logger.logError("Graph service exception " + ex.getMessage(shouldLogVerbosely), ex);
453-
throw ex;
454-
} catch (final Exception ex) {
455-
final ClientException clientException = new ClientException("Error during http request",
456-
ex);
457-
logger.logError("Error during http request", clientException);
458-
throw clientException;
459459
}
460460
}
461461
/**
@@ -496,12 +496,7 @@ private <Result> Result handleJsonResponse(final InputStream in, Map<String, Lis
496496
return null;
497497
}
498498

499-
try {
500-
return serializer.deserializeObject(in, clazz, responseHeaders);
501-
} finally {
502-
closeQuietly(in);
503-
}
504-
499+
return serializer.deserializeObject(in, clazz, responseHeaders);
505500
}
506501
/**
507502
* Handles the cause where the response is a Text object
@@ -538,8 +533,13 @@ private <Result> Result handleRawResponse(final InputStream in, final Class<Resu
538533
private <Result> Result handleEmptyResponse(Map<String, List<String>> responseHeaders, final Class<Result> clazz)
539534
throws UnsupportedEncodingException{
540535
//Create an empty object to attach the response headers to
541-
InputStream in = new ByteArrayInputStream("{}".getBytes(Constants.JSON_ENCODING));
542-
return handleJsonResponse(in, responseHeaders, clazz);
536+
Result result = null;
537+
try(final InputStream in = new ByteArrayInputStream("{}".getBytes(Constants.JSON_ENCODING))) {
538+
result = handleJsonResponse(in, responseHeaders, clazz);
539+
} catch (IOException ex) {
540+
//noop we couldnt close the byte array stream we just opened and its ok
541+
}
542+
return result;
543543
}
544544

545545
private Request convertIHttpRequestToOkHttpRequest(IHttpRequest request) {

0 commit comments

Comments
 (0)