Reimplement OAuth2 library - Step 1

Src/GoogleApis/Apis/Http/ConfigurableMessageHandler.cs

 /*
 Copyright 2013 Google Inc
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
 http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
@@ skipping 11 matching lines @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 using Google.Apis.Logging;
 using Google.Apis.Testing;
 
 namespace Google.Apis.Http
 {
 /// <summary>
- /// This message handler contains the main logic of our Http requests. It co
 ntains a list of·
+ /// This message handler contains the main logic of our HTTP requests. It co
 ntains a list of·
 /// <see cref="IHttpUnsuccessfulResponseHandler"/>s for handling abnormal re
sponses, a list of·
 /// <see cref="IHttpExceptionHandler"/>s for handling exception in a request
and a list of·
 /// <see cref="IHttpExecuteInterceptor"/>s for intercepting a request before
it has been sent to the server.
- /// It also contains important properties like num of retires, follow redire
 ct, etc.
+ /// It also contains important properties like number of tires, follow redir
 ect, etc.

[class, 2013/09/21 03:12:10]

Should this be number of retries?

[peleyal, 2013/09/23 12:01:16]

tries
The property is NumTries.
On 2013/09/21 03:12:10, class wrote:

 /// </summary>
 public class ConfigurableMessageHandler : DelegatingHandler
 {
- /// <summary> The class logger. </summary>
+ /// <summary>The class logger.</summary>
 private static readonly ILogger Logger = ApplicationContext.Logger.ForTy
pe<ConfigurableMessageHandler>();
 
- /// <summary> Maximum allowed number of tries. </summary>
+ /// <summary>Maximum allowed number of tries.</summary>
 [VisibleForTestOnly]
 internal const int MaxAllowedNumTries = 20;
 
- /// <summary> The current API version of this client library. </summary>
+ /// <summary>The current API version of this client library.</summary>
 private static readonly string ApiVersion = Google.Apis.Util.Utilities.G
etLibraryVersion();
 
- /// <summary> The User-Agent suffix header which contains the <seealso c
 ref="ApiVersion"/>. </summary>
+ /// <summary>The User-Agent suffix header which contains the <seealso cr
 ef="ApiVersion"/>.</summary>
 private static readonly string UserAgentSuffix = "google-api-dotnet-clie
nt/" ApiVersion " (gzip)";
 
 #region IHttpUnsuccessfulResponseHandler, IHttpExceptionHandler and IHtt
pExecuteInterceptor lists
 
- /// <summary> A list of <see cref="IHttpUnsuccessfulResponseHandler"/>. 
 </summary>
+ /// <summary>A list of <see cref="IHttpUnsuccessfulResponseHandler"/>.</
 summary>
 private readonly IList<IHttpUnsuccessfulResponseHandler> unsuccessfulRes
ponseHandlers =
 new List<IHttpUnsuccessfulResponseHandler>();
 
- /// <summary> A list of <see cref="IHttpExceptionHandler"/>. </summary>
+ /// <summary>A list of <see cref="IHttpExceptionHandler"/>.</summary>
 private readonly IList<IHttpExceptionHandler> exceptionHandlers =
 new List<IHttpExceptionHandler>();
 
- /// <summary> A list of <see cref="IHttpExecuteInterceptor"/>. </summary
 >
+ /// <summary>A list of <see cref="IHttpExecuteInterceptor"/>.</summary>
 private readonly IList<IHttpExecuteInterceptor> executeInterceptors =
 new List<IHttpExecuteInterceptor>();
 
- /// <summary> Gets a list of <see cref="IHttpUnsuccessfulResponseHandler
 "/>. </summary>
+ /// <summary>Gets a list of <see cref="IHttpUnsuccessfulResponseHandler"
 />.</summary>
 public IList<IHttpUnsuccessfulResponseHandler> UnsuccessfulResponseHandl
ers
 {
 get { return unsuccessfulResponseHandlers; }
 }
 
- /// <summary> Gets a list of <see cref="IHttpExceptionHandler"/>. </summ
 ary>
+ /// <summary>Gets a list of <see cref="IHttpExceptionHandler"/>.</summar
 y>
 public IList<IHttpExceptionHandler> ExceptionHandlers
 {
 get { return exceptionHandlers; }
 }
 
- /// <summary> Gets a list of <see cref="IHttpExecuteInterceptor"/>. </su
 mmary>
+ /// <summary>Gets a list of <see cref="IHttpExecuteInterceptor"/>.</summ
 ary>
 public IList<IHttpExecuteInterceptor> ExecuteInterceptors
 {
 get { return executeInterceptors; }
 }
 
 #endregion
 
- /// <summary> Number of tries. Default is <c>3</c>. </summary>
+ /// <summary>Number of tries. Default is <c>3</c>.</summary>
 private int numTries = 3;
 
- /// <summary> 
+ /// <summary>
 /// Gets or sets the number of tries that will be allowed to execute. Re
tries occur as a result of either
 /// <see cref="IHttpUnsuccessfulResponseHandler"/> or <see cref="IHttpEx
ceptionHandler"/> which handles the
- /// abnormal Http response or exception, before being terminated.·
+ /// abnormal HTTP response or exception, before being terminated.·
 /// Set <c>1</c> for not retrying requests. The default value is <c>3</c
>".
 /// </summary>
 public int NumTries
 {
 get { return numTries; }
 set
 {
 if (value > MaxAllowedNumTries || value < 1)
 {
 throw new ArgumentOutOfRangeException("NumTries");
 }
 numTries = value;
 }
 }
 
- /// <summary> 
+ /// <summary>
 /// Gets or sets whether the handler should follow a redirect when a red
irect response is received. Default·
 /// value is <c>true</c>.
 /// </summary>
 public bool FollowRedirect { get; set; }
 
- /// <summary> Gets or sets whether logging is enabled. Default value is 
 <c>true</c>. </summary>
+ /// <summary>Gets or sets whether logging is enabled. Default value is <
 c>true</c>.</summary>
 public bool IsLoggingEnabled { get; set; }
 
- /// <summary> Gets or sets the application name which will be used on th
 e User-Agent header. </summary>
+ /// <summary>Gets or sets the application name which will be used on the
  User-Agent header.</summary>
 public string ApplicationName { get; set; }
 
- /// <summary> Constructs a new configurable message handler </summary>
+ /// <summary>Constructs a new configurable message handler </summary>
 public ConfigurableMessageHandler(HttpMessageHandler httpMessageHandler)
 : base(httpMessageHandler)
 {
 // set default values
 FollowRedirect = true;
 IsLoggingEnabled = true;
 }
 
 /// <summary>
 /// The main logic of sending a request to the server. This send method
adds the User-Agent header to a request
 /// with <see cref="ApplicationName"/> and the library version. It also
calls interceptors before each attempt,
 /// and unsuccessful response handler or exception handlers when abnorma
l response or exception occurred.
 /// </summary>
 protected override async Task<HttpResponseMessage> SendAsync(HttpRequest
Message request,
 CancellationToken cancellationToken)
 {
 var loggable = IsLoggingEnabled && Logger.IsDebugEnabled;
 
 int triesRemaining = NumTries;
 Exception lastException = null;
 
- // set User-Agent header
+ // Set User-Agent header.
 var userAgent = (ApplicationName == null ? "" : ApplicationName "
") UserAgentSuffix;
 // TODO: setting the User-Agent won't work on Silverlight. We may ne
ed to create a special callback here to·
- // set it correctly. Also check what happen in WP?
+ // set it correctly.
 request.Headers.Add("User-Agent", userAgent);
 
 HttpResponseMessage response = null;
- do // while (triesRemaining > 0)
+ do // While (triesRemaining > 0)
 {
 cancellationToken.ThrowIfCancellationRequested();
 
 if (response != null)
 {
 response.Dispose();
 response = null;
 }
 lastException = null;
 
- // intercept the request
- // TODO(peleyal): rethink if each execute interceptor should be 
 implemented as DelegateHandler, and·
- // then remove this execute interceptor!
+ // Intercept the request.
 foreach (var interceptor in executeInterceptors)
 {
- interceptor.Intercept(request);
+ await interceptor.InterceptAsync(request, cancellationToken)
 .ConfigureAwait(false);
 }
 
 try
 {
- // send the request!
+ // Send the request!
 response = await base.SendAsync(request, cancellationToken).
ConfigureAwait(false);
 }
 catch (Exception ex)
 {
 lastException = ex;
 }
 
- // decrease the number of retries
+ // Decrease the number of retries.
 triesRemaining--;
 
- // exception was thrown , try to handle it
+ // Exception was thrown, try to handle it.
 if (response == null)
 {
 var exceptionHandled = false;
 
- // try to handle the exception with each handler
+ // Try to handle the exception with each handler.
 foreach (var handler in exceptionHandlers)
 {
- exceptionHandled |= handler.HandleException(new HandleEx
 ceptionArgs
+ exceptionHandled |= await handler.HandleExceptionAsync(n
 ew HandleExceptionArgs
 {
 Request = request,
 Exception = lastException,
 TotalTries = NumTries,
 CurrentFailedTry = NumTries - triesRemaining,
 CancellationToken = cancellationToken
- });
+ }).ConfigureAwait(false);
 }
 
 if (!exceptionHandled)
 {
 Logger.Error(lastException,
- "Exception was thrown while executing an Http reques
 t and it wasn't handled");
+ "Exception was thrown while executing a HTTP request
  and it wasn't handled");
 throw lastException;
 }
 else if (loggable)
 {
 Logger.Debug("Exception {0} was thrown, but it was handl
ed by an exception handler",
 lastException.Message);
 }
 }
 else
 {
 if (response.IsSuccessStatusCode)
 {
- // no need to retry, the response was successful
+ // No need to retry, the response was successful.
 triesRemaining = 0;
 }
 else
 {
 bool errorHandled = false;
 
- // try to handle the abnormal Http response with each ha
 ndler
+ // Try to handle the abnormal HTTP response with each ha
 ndler.
 foreach (var handler in unsuccessfulResponseHandlers)
 {
- errorHandled |= handler.HandleResponse(new HandleUns
 uccessfulResponseArgs
+ errorHandled |= await handler.HandleResponseAsync(ne
 w HandleUnsuccessfulResponseArgs
 {
 Request = request,
 Response = response,
 TotalTries = NumTries,
 CurrentFailedTry = NumTries - triesRemaining
,
 CancellationToken = cancellationToken
- });
+ }).ConfigureAwait(false);
 }
 
 if (!errorHandled)
 {
 if (HandleRedirect(response))
 {
 errorHandled = true;
 if (loggable)
 {
 Logger.Debug("Redirect response was handled
successfully. Redirect to {0}",
 response.Headers.Location);
 }
 }
 else
 {
 if (loggable)
 {
 Logger.Debug("An abnormal response wasn't ha
ndled. Status code is {0}",
 response.StatusCode);
 }
 
- // no need to retry, because no handler handled 
 the abnormal response
+ // No need to retry, because no handler handled 
 the abnormal response.
 triesRemaining = 0;
 }
 }
 else if (loggable)
 {
 Logger.Debug("An abnormal response was handled by an
unsuccessful response handler. " 
 "Status Code is {0}", response.StatusCode);
 }
 }
 }
- } while (triesRemaining > 0); // not a success status code but it wa
 s handled
+ } while (triesRemaining > 0); // Not a successful status code but it
  was handled.
 
- // if the response is null, we should throw the last exception
+ // If the response is null, we should throw the last exception.
 if (response == null)
 {
- Logger.Error(lastException, "Exception was thrown while executin
 g an Http request");
+ Logger.Error(lastException, "Exception was thrown while executin
 g a HTTP request");
 throw lastException;
 }
 else if (!response.IsSuccessStatusCode)
 {
 Logger.Debug("Abnormal response is being returned. Status Code i
s {0}", response.StatusCode);
 }
 
 return response;
 }
 
@@ skipping 13 matching lines @@
 return false;
 }
 
 var request = message.RequestMessage;
 request.RequestUri = new Uri(request.RequestUri, uri);
 // Status code for a resource that has moved to a new URI and should
be retrieved using GET.
 if (message.StatusCode == HttpStatusCode.SeeOther)
 {
 request.Method = HttpMethod.Get;
 }
- // clear Authorization and If-* headers
+ // Clear Authorization and If-* headers.
 request.Headers.Remove("Authorization");
 request.Headers.IfMatch.Clear();
 request.Headers.IfNoneMatch.Clear();
 request.Headers.IfModifiedSince = null;
 request.Headers.IfUnmodifiedSince = null;
 request.Headers.Remove("If-Range");
 return true;
 }
 }
 }