added dependency on core, added okhttpprovider

Author: Nakul Sabharwal

build.gradle

@@ -20,6 +20,9 @@ repositories {
     // You can declare any Maven/Ivy/file repository here.
     jcenter()
     mavenCentral()
+    jcenter{
+        url 'http://oss.jfrog.org/artifactory/oss-snapshot-local'
+    }
 }
 
 dependencies {
@@ -35,6 +38,9 @@ dependencies {
     compile 'com.google.code.gson:gson:2.8.2'
 
     compile 'com.sun.jersey:jersey-server:1.19.4'
+    
+    // Core Http library 
+    compile('com.microsoft.graph:microsoft-graph-core:0.1.0-SNAPSHOT')
 }
 
 def pomConfig = {

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

@@ -22,19 +22,21 @@
 
 package com.microsoft.graph.concurrency;
 
-import com.microsoft.graph.requests.extensions.ChunkedUploadResult;
-import com.microsoft.graph.models.extensions.UploadSession;
+import java.io.BufferedInputStream;
+import java.io.InputStream;
+
 import com.microsoft.graph.http.DefaultHttpProvider;
 import com.microsoft.graph.http.GraphServiceException;
 import com.microsoft.graph.http.HttpResponseCode;
 import com.microsoft.graph.http.IConnection;
 import com.microsoft.graph.http.IHttpRequest;
 import com.microsoft.graph.http.IStatefulResponseHandler;
 import com.microsoft.graph.logger.ILogger;
+import com.microsoft.graph.models.extensions.UploadSession;
+import com.microsoft.graph.requests.extensions.ChunkedUploadResult;
 import com.microsoft.graph.serializer.ISerializer;
 
-import java.io.BufferedInputStream;
-import java.io.InputStream;
+import okhttp3.Response;
 
 /**
  * Handles the stateful response from the OneDrive upload session
@@ -118,4 +120,56 @@ public ChunkedUploadResult<UploadType> generateResult(
 
         return null;
     }
+    
+    /**
+     * Generate the chunked upload response result
+     *
+     * @param request    the HTTP request
+     * @param connection the HTTP connection
+     * @param serializer the serializer
+     * @param logger     the system logger
+     * @return the chunked upload result, which could be either an uploaded item or error
+     * @throws Exception an exception occurs if the request was unable to complete for any reason
+     */
+    @Override
+    public ChunkedUploadResult<UploadType> generateResult(
+            final IHttpRequest request,
+            final Response response,
+            final ISerializer serializer,
+            final ILogger logger) throws Exception {
+        InputStream in = null;
+
+        try {
+            if (response.code() == HttpResponseCode.HTTP_ACCEPTED) {
+                logger.logDebug("Chunk bytes has been accepted by the server.");
+                in = new BufferedInputStream(response.body().byteStream());
+                final UploadSession session = serializer.deserializeObject(
+                        DefaultHttpProvider.streamToString(in), UploadSession.class);
+
+                return new ChunkedUploadResult<UploadType>(session);
+
+            } else if (response.code() == HttpResponseCode.HTTP_CREATED
+                    || response.code() == HttpResponseCode.HTTP_OK) {
+                logger.logDebug("Upload session is completed, uploaded item returned.");
+                in = new BufferedInputStream(response.body().byteStream());
+                String rawJson = DefaultHttpProvider.streamToString(in);
+                UploadType uploadedItem = serializer.deserializeObject(rawJson,
+                        this.deserializeTypeClass);
+
+                return new ChunkedUploadResult<UploadType>(uploadedItem);
+            } else if (response.code() >= HttpResponseCode.HTTP_CLIENT_ERROR) {
+                logger.logDebug("Receiving error during upload, see detail on result error");
+
+                return new ChunkedUploadResult<UploadType>(
+                        GraphServiceException.createFromConnection(request, null, serializer,
+                                response, logger));
+            }
+        } finally {
+            if (in != null) {
+                in.close();
+            }
+        }
+
+        return null;
+    }
 }

src/main/java/com/microsoft/graph/core/DefaultClientConfig.java

@@ -25,13 +25,14 @@
 import com.microsoft.graph.authentication.IAuthenticationProvider;
 import com.microsoft.graph.concurrency.DefaultExecutors;
 import com.microsoft.graph.concurrency.IExecutors;
-import com.microsoft.graph.http.DefaultHttpProvider;
 import com.microsoft.graph.http.IHttpProvider;
 import com.microsoft.graph.logger.DefaultLogger;
 import com.microsoft.graph.logger.ILogger;
 import com.microsoft.graph.serializer.DefaultSerializer;
 import com.microsoft.graph.serializer.ISerializer;
 
+import demo.OkHttpProvider;
+
 /**
  * The default configuration for a service client
  */
@@ -45,7 +46,7 @@ public abstract class DefaultClientConfig implements IClientConfig {
     /**
      * The HTTP provider instance
      */
-    private DefaultHttpProvider httpProvider;
+    private IHttpProvider httpProvider;
 
     /**
      * The logger
@@ -98,11 +99,12 @@ public IAuthenticationProvider getAuthenticationProvider() {
     @Override
     public IHttpProvider getHttpProvider() {
         if (httpProvider == null) {
-            httpProvider = new DefaultHttpProvider(getSerializer(),
+        	System.out.println("---------------------------USING OKHTTP PROVIDER----------------------------");
+            httpProvider = new OkHttpProvider(getSerializer(),
                     getAuthenticationProvider(),
                     getExecutors(),
                     getLogger());
-            getLogger().logDebug("Created DefaultHttpProvider");
+            getLogger().logDebug("Created OkHttpProvider");
         }
         return httpProvider;
     }

src/main/java/com/microsoft/graph/http/BaseStreamRequest.java

@@ -25,6 +25,8 @@
 import com.microsoft.graph.concurrency.ICallback;
 import com.microsoft.graph.core.ClientException;
 import com.microsoft.graph.core.IBaseClient;
+import com.microsoft.graph.httpcore.middlewareoption.IShouldRedirect;
+import com.microsoft.graph.httpcore.middlewareoption.IShouldRetry;
 import com.microsoft.graph.options.HeaderOption;
 import com.microsoft.graph.options.Option;
 
@@ -43,6 +45,12 @@ public abstract class BaseStreamRequest<T> implements IHttpStreamRequest {
      * The base request for this collection request
      */
     private final BaseRequest baseRequest;
+    
+    private int maxRedirect;
+    private IShouldRedirect shouldRedirect;
+    private long delay;
+    private int maxRetries;
+    private IShouldRetry shouldRetry;
 
     /**
      * Creates the stream request.
@@ -175,4 +183,49 @@ public List<HeaderOption> getHeaders() {
     public List<Option> getOptions() {
         return baseRequest.getOptions();
     }
+    
+    /**
+	 * Sets maximum number of redirects
+	 * @param maxRedirect Maximum number of redirects <= 20
+	 */
+	public IHttpRequest setMaxRedirect(int maxRedirect) {
+		this.maxRedirect = maxRedirect;
+		return this;
+	}
+
+	/**
+	 * Sets IShouldRedirect callback
+	 * @param shouldRedirect Callbacks to IShouldRedirect to decides to redirect or not
+	 */
+	public IHttpRequest setShouldRedirect(IShouldRedirect shouldRedirect) {
+		this.shouldRedirect = shouldRedirect;
+		return this;
+	}
+
+	/**
+	 * Sets Delay in seconds between retries
+	 * @param delay Delay in seconds between retries
+	 */
+	public IHttpRequest setDelay(long delay) {
+		this.delay = delay;
+		return this;
+	}
+
+	/**
+	 * Sets maximum number of retries
+	 * @param maxRetries Maximum number of retries <= 10
+	 */
+	public IHttpRequest setMaxRetries(int maxRetries) {
+		this.maxRetries = maxRetries;
+		return this;
+	}
+
+	/**
+	 * Sets IShouldRetry callback
+	 * @param shouldRetry Callback to decide to retry or not
+	 */
+	public IHttpRequest setShouldRetry(IShouldRetry shouldRetry) {
+		this.shouldRetry = shouldRetry;
+		return this;
+	}
 }

src/main/java/com/microsoft/graph/http/GraphServiceException.java

@@ -31,12 +31,14 @@
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.microsoft.graph.core.ClientException;
-import com.microsoft.graph.core.GraphErrorCodes;
 import com.microsoft.graph.logger.ILogger;
 import com.microsoft.graph.logger.LoggerLevel;
 import com.microsoft.graph.options.HeaderOption;
 import com.microsoft.graph.serializer.ISerializer;
 
+import demo.OkHttpProvider;
+import okhttp3.Response;
+
 /**
  * An exception from the Graph service
  */
@@ -346,4 +348,103 @@ public static <T> GraphServiceException createFromConnection(final IHttpRequest
                 error,
                 isVerbose);
     }
+    
+    /**
+     * Creates a Graph service exception from a given failed HTTP request
+     *
+     * @param request      the request that resulted in this failure
+     * @param serializable the serialized object that was sent with this request
+     * @param serializer   the serializer to re-create the option in its over the wire state
+     * @param connection   the connection that was used to extract the response information from
+     * @param logger       the logger to log exception information to
+     * @param <T>          the type of the serializable object
+     * @return             the new GraphServiceException instance
+     * @throws IOException an exception occurs if there were any problems processing the connection
+     */
+    public static <T> GraphServiceException createFromConnection(final IHttpRequest request,
+                                                                 final T serializable,
+                                                                 final ISerializer serializer,
+                                                                 final Response response,
+                                                                 final ILogger logger)
+            throws IOException {
+        final String method = response.request().method();
+        final String url = request.getRequestUrl().toString();
+        final List<String> requestHeaders = new LinkedList<>();
+        for (final HeaderOption option : request.getHeaders()) {
+            requestHeaders.add(option.getName() + " : " + option.getValue());
+        }
+        boolean isVerbose = logger.getLoggingLevel() == LoggerLevel.DEBUG;
+        final String requestBody;
+        if (serializable instanceof byte[]) {
+            final byte[] bytes = (byte[]) serializable;
+            StringBuilder sb = new StringBuilder();
+            sb.append("byte[").append(bytes.length).append("]");
+
+            sb.append(" {");
+            if (isVerbose) {
+            	sb.append(bytes);
+            } else {
+	            for (int i = 0; i < MAX_BYTE_COUNT_BEFORE_TRUNCATION && i < bytes.length; i++) {
+	                sb.append(bytes[i]).append(", ");
+	            }
+	            if (bytes.length > MAX_BYTE_COUNT_BEFORE_TRUNCATION) {
+	                sb.append(TRUNCATION_MARKER).append("}");
+	            }
+            }
+            requestBody = sb.toString();
+        } else if (serializable != null) {
+            requestBody = serializer.serializeObject(serializable);
+        } else {
+            requestBody = null;
+        }
+
+        final int responseCode = response.code();
+        final List<String> responseHeaders = new LinkedList<>();
+        final Map<String, String> headers = OkHttpProvider.getResponseHeadersAsMapStringString(response);
+        for (final String key : headers.keySet()) {
+            final String fieldPrefix;
+            if (key == null) {
+                fieldPrefix = "";
+            } else {
+                fieldPrefix = key + " : ";
+            }
+            responseHeaders.add(fieldPrefix + headers.get(key));
+        }
+
+        final String responseMessage = response.message();
+        final String rawOutput = DefaultHttpProvider.streamToString(response.body().byteStream());
+        GraphErrorResponse error;
+        try {
+            error = serializer.deserializeObject(rawOutput, GraphErrorResponse.class, OkHttpProvider.getResponseHeadersAsMapOfStringList(response));
+        } catch (final Exception ex) {
+            error = new GraphErrorResponse();
+            error.error = new GraphError();
+            error.error.code = "Unable to parse error response message";
+            error.error.message = "Raw error: " + rawOutput;
+            error.error.innererror = new GraphInnerError();
+            error.error.innererror.code = ex.getMessage();
+        }
+
+        if (responseCode >= INTERNAL_SERVER_ERROR) {
+            return new GraphFatalServiceException(method,
+                    url,
+                    requestHeaders,
+                    requestBody,
+                    responseCode,
+                    responseMessage,
+                    responseHeaders,
+                    error,
+                    isVerbose);
+        }
+
+        return new GraphServiceException(method,
+                url,
+                requestHeaders,
+                requestBody,
+                responseCode,
+                responseMessage,
+                responseHeaders,
+                error,
+                isVerbose);
+    }
 }

src/main/java/com/microsoft/graph/http/IStatefulResponseHandler.java

@@ -26,6 +26,8 @@
 import com.microsoft.graph.logger.ILogger;
 import com.microsoft.graph.serializer.ISerializer;
 
+import okhttp3.Response;
+
 /**
  * The handler interface for requests having stateful response from server.
  * The handler will custom the HTTP connection if needed and generate request
@@ -56,4 +58,19 @@ ResultType generateResult(final IHttpRequest request,
                               final IConnection connection,
                               final ISerializer serializer,
                               final ILogger logger) throws Exception;
+    
+    /**
+     * Generate result after receiving response
+     *
+     * @param request    the HTTP request
+     * @param connection the HTTP connection
+     * @param serializer the serializer for parsing response
+     * @param logger     the logger
+     * @return           the result generated by this handler
+     * @throws Exception an exception occurs if the request was unable to complete for any reason
+     */
+    ResultType generateResult(final IHttpRequest request,
+                              final Response response,
+                              final ISerializer serializer,
+                              final ILogger logger) throws Exception;
 }