Reimplement OAuth2 library - Step 1

Src/GoogleApis/Apis/[Media]/Upload/ResumableUpload.cs

 /*
 Copyright 2012 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 27 matching lines @@
 /// See: https://developers.google.com/drive/manage-uploads#resumable for mo
re information on the protocol.
 /// </remarks>
 /// <typeparam name="TRequest">
 /// The type of the body of this request. Generally this should be the metad
ata related to the content to be·
 /// uploaded. Must be serializable to/from JSON.
 /// </typeparam>
 public class ResumableUpload<TRequest>
 {
 #region Constants
 
- /// <summary> The class logger. </summary>
+ /// <summary>The class logger.</summary>
 private static readonly ILogger logger = ApplicationContext.Logger.ForTy
pe<ResumableUpload<TRequest>>();
 
 private const int KB = 0x400;
 private const int MB = 0x100000;
 
- /// <summary> Minimum chunk size (except the last one). Default value is
  256*KB. </summary>
+ /// <summary>Minimum chunk size (except the last one). Default value is 
 256*KB.</summary>
 public const int MinimumChunkSize = 256 * KB;
 
- /// <summary> Default chunk size. Default value is 10*MB. </summary>
+ /// <summary>Default chunk size. Default value is 10*MB.</summary>
 public const int DefaultChunkSize = 10 * MB;
 
 /// <summary>
 /// Defines how many bytes are read from the input stream in each stream
read action.·
 /// The read will continue until we read <see cref="MinimumChunkSize"/>
or we reached the end of the stream.
 /// </summary>
 internal int BufferSize = 4 * KB;
 
- /// <summary> Indicates the stream's size is unknown. </summary>
+ /// <summary>Indicates the stream's size is unknown.</summary>
 private const int UnknownSize = -1;
 
- /// <summary> The mime type for the encoded JSON body. </summary>
+ /// <summary>The mime type for the encoded JSON body.</summary>
 private const string JsonMimeType = "application/json; charset=UTF-8";
 
- /// <summary> Payload description headers, describing the content itself
 . </summary>
+ /// <summary>Payload description headers, describing the content itself.
 </summary>
 private const string PayloadContentTypeHeader = "X-Upload-Content-Type";
 
- /// <summary> Payload description headers, describing the content itself
 . </summary>
+ /// <summary>Payload description headers, describing the content itself.
 </summary>
 private const string PayloadContentLengthHeader = "X-Upload-Content-Leng
th";
 
- /// <summary> Specify the type of this upload (this class supports resum
 able only). </summary>
+ /// <summary>Specify the type of this upload (this class supports resuma
 ble only).</summary>
 private const string UploadType = "uploadType";
 
- /// <summary> The uploadType parameter value for resumable uploads. </su
 mmary>
+ /// <summary>The uploadType parameter value for resumable uploads.</summ
 ary>
 private const string Resumable = "resumable";
 
- /// <summary> Content-Range header value for the body upload of zero len
 gth files. </summary>
+ /// <summary>Content-Range header value for the body upload of zero leng
 th files.</summary>
 private const string ZeroByteContentRangeHeader = "bytes */0";
 
 #endregion // Constants
 
 #region Construction
 
 /// <summary>
 /// Create a resumable upload instance with the required parameters.
 /// </summary>
 /// <param name="service">The client service.</param>
@@ skipping 19 matching lines @@
 this.Path = path;
 this.HttpMethod = httpMethod;
 this.ContentStream = contentStream;
 this.ContentType = contentType;
 }
 
 #endregion // Construction
 
 #region Properties
 
- /// <summary> Gets or sets the service. </summary>
+ /// <summary>Gets or sets the service.</summary>
 public IClientService Service { get; private set; }
 
- /// <summary> 
+ /// <summary>
 /// Gets or sets the path of the method (combined with <see cref="IClien
tService.BaseUri"/>) to produce·
 /// absolute Uri.·
 /// </summary>
 public string Path { get; private set; }
 
- /// <summary> Gets or sets the HTTP method of this upload (used to initi
 alize the upload). </summary>
+ /// <summary>Gets or sets the HTTP method of this upload (used to initia
 lize the upload).</summary>
 public string HttpMethod { get; private set; }
 
- /// <summary> Gets or sets the stream to upload. </summary>
+ /// <summary>Gets or sets the stream to upload.</summary>
 public Stream ContentStream { get; private set; }
 
- /// <summary> Gets or sets the stream's Content-Type. </summary>
+ /// <summary>Gets or sets the stream's Content-Type.</summary>
 public string ContentType { get; private set; }
 
 /// <summary>
 /// Gets or sets the length of the steam. Will be <see cref="UnknownSize
" /> if the media content length is·
 /// unknown.·
 /// </summary>
 private long StreamLength { get; set; }
 
 /// <summary>
 /// Gets or sets the content of the last buffer request to the server or
<c>null</c> for none. It is used when·
 /// the media content length is unknown, for resending it in case of ser
ver error.
 /// </summary>
 private byte[] LastMediaRequest { get; set; }
 
- /// <summary> Gets or sets cached byte which indicates if end of stream 
 has been reached. </summary>
+ /// <summary>Gets or sets cached byte which indicates if end of stream h
 as been reached.</summary>
 private byte[] CachedByte { get; set; }
 
- /// <summary> Gets or sets the last request length. </summary>
+ /// <summary>Gets or sets the last request length.</summary>
 private int LastMediaLength { get; set; }
 
- /// <summary> 
+ /// <summary>
 /// Gets or sets the resumable session Uri.·
 /// See https://developers.google.com/drive/manage-uploads#save-session-
uri" for more details.
 /// </summary>
 private Uri UploadUri { get; set; }
 
- /// <summary> Gets or sets the amount of bytes the server had received s
 o far. </summary>
+ /// <summary>Gets or sets the amount of bytes the server had received so
  far.</summary>
 private long BytesServerReceived { get; set; }
 
- /// <summary> Gets or sets the amount of bytes the client had sent so fa
 r. </summary>
+ /// <summary>Gets or sets the amount of bytes the client had sent so far
 .</summary>
 private long BytesClientSent { get; set; }
 
- /// <summary> Gets or sets the body of this request. </summary>
+ /// <summary>Gets or sets the body of this request.</summary>
 public TRequest Body { get; set; }
 
 [VisibleForTestOnly]
 internal int chunkSize = DefaultChunkSize;
 
- /// <summary> 
+ /// <summary>
 /// Gets or sets the size of each chunk sent to the server.
 /// Chunks (except the last chunk) must be a multiple of <see cref="Mini
mumChunkSize"/> to be compatible with·
 /// Google upload servers.
 /// </summary>
 public int ChunkSize
 {
 get { return chunkSize; }
 set
 {
 if (value < MinimumChunkSize)
 {
 throw new ArgumentOutOfRangeException("ChunkSize");
 }
 chunkSize = value;
 }
 }
 
 #endregion // Properties
 
 #region Events
 
- /// <summary> Event called whenever the progress of the upload changes. 
 </summary>
+ /// <summary>Event called whenever the progress of the upload changes.</
 summary>
 public event Action<IUploadProgress> ProgressChanged;
 
 #endregion //Events
 
 #region Error handling (Exception and 5xx)
 
 /// <summary>
 /// Callback class that is invoked on abnormal response or an exception.
 /// This class changes the request to query the current status of the up
load in order to find how many bytes··
 /// were successfully uploaded before the error occurred.
 /// See https://developers.google.com/drive/manage-uploads#resume-upload
for more details.
 /// </summary>
 class ServerErrorCallback : IHttpUnsuccessfulResponseHandler, IHttpExcep
tionHandler, IDisposable
 {
 private ResumableUpload<TRequest> Owner { get; set; }
 
- /// <summary> 
+ /// <summary>
 /// Constructs a new callback and register it as unsuccessful respon
se handler and exception handler on the·
 /// configurable message handler.
 /// </summary>
 public ServerErrorCallback(ResumableUpload<TRequest> resumable)
 {
 this.Owner = resumable;
 Owner.Service.HttpClient.MessageHandler.UnsuccessfulResponseHand
lers.Add(this);
 Owner.Service.HttpClient.MessageHandler.ExceptionHandlers.Add(th
is);
 }
 
@@ skipping 20 matching lines @@
 public Task<bool> HandleExceptionAsync(HandleExceptionArgs args)
 {
 var result = args.SupportsRetry && !args.CancellationToken.IsCan
cellationRequested &&
 args.Request.RequestUri.Equals(Owner.UploadUri) ? OnServerEr
ror(args.Request) : false;
 
 TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(
);
 tcs.SetResult(result);
 return tcs.Task;
 }
 
- /// <summary> Changes the request in order to resume the interrupted
  upload. </summary>
+ /// <summary>Changes the request in order to resume the interrupted 
 upload.</summary>
 private bool OnServerError(HttpRequestMessage request)
 {
 // clear all headers and set Content-Range and Content-Length he
aders
 var range = String.Format("bytes */{0}", Owner.StreamLength < 0
? "*" : Owner.StreamLength.ToString());
 request.Headers.Clear();
 request.Method = System.Net.Http.HttpMethod.Put;
 request.SetEmptyContent().Headers.Add("Content-Range", range);
 return true;
 }
 
 public void Dispose()
 {
 Owner.Service.HttpClient.MessageHandler.UnsuccessfulResponseHand
lers.Remove(this);
 Owner.Service.HttpClient.MessageHandler.ExceptionHandlers.Remove
(this);
 }
 }
 
 #endregion
 
 #region Progress Monitoring
 
- /// <summary> Class that communicates the progress of resumable uploads 
 to a container. </summary>
+ /// <summary>Class that communicates the progress of resumable uploads t
 o a container.</summary>
 private class ResumableUploadProgress : IUploadProgress
 {
 /// <summary>
 /// Create a ResumableUploadProgress instance.
 /// </summary>
 /// <param name="status">The status of the upload.</param>
 /// <param name="bytesSent">The number of bytes sent so far.</param>
 public ResumableUploadProgress(UploadStatus status, long bytesSent)
 {
 Status = status;
@@ skipping 85 matching lines @@
 }
 catch (Exception ex)
 {
 logger.Error(ex, "MediaUpload[{0}] - Exception occurred while up
loading media", UploadUri);
 UpdateProgress(new ResumableUploadProgress(ex, BytesServerReceiv
ed));
 }
 
 return Progress;
 }
 
- /// <summary> Uploads the content asynchronously to the server.</summary
 >
+ /// <summary>Uploads the content asynchronously to the server.</summary>
 /// <remarks>
 /// In case the upload fails the task will not be completed. In that cas
e the task's·
 /// <seealso cref="System.Threading.Tasks.Task.Exception"/> property wil
l bet set, or its·
 /// <seealso cref="System.Threading.Tasks.Task.IsCanceled"/> property wi
ll be true.
 /// </remarks>
 public Task<IUploadProgress> UploadAsync()
 {
 return UploadAsync(CancellationToken.None);
 }
 
- /// <summary> Uploads the content asynchronously to the server.</summary
 >
+ /// <summary>Uploads the content asynchronously to the server.</summary>
 /// <param name="cancellationToken">The cancellation token to cancel a r
equest in the middle.</param>
 public Task<IUploadProgress> UploadAsync(CancellationToken cancellationT
oken)
 {
 TaskCompletionSource<IUploadProgress> tcs = new TaskCompletionSource
<IUploadProgress>();
 Task.Factory.StartNew(async () =>
 {
 try
 {
 var response = await Upload(cancellationToken).ConfigureAwai
t(false);
 if (response.Exception != null)
@@ skipping 29 matching lines @@
 }
 
 /// <summary>
 /// Process a response from the final upload chunk call.
 /// </summary>
 /// <param name="httpResponse">The response body from the final uploaded
chunk.</param>
 protected virtual void ProcessResponse(HttpResponseMessage httpResponse)
 {
 }
 
- /// <summary> 
+ /// <summary>
 /// Uploads the next chunk of data to the server.
 /// </summary>
 /// <returns>·
 /// <c>True</c> if the entire media has been completely uploaded.
 /// </returns>
 protected async Task<bool> SendNextChunk(Stream stream, CancellationToke
n cancellationToken)
 {
 cancellationToken.ThrowIfCancellationRequested();
 
 HttpRequestMessage request = new RequestBuilder()
@@ skipping 28 matching lines @@
 // The upload protocol uses 308 to indicate that there is more d
ata expected from the server.
 BytesServerReceived = GetNextByte(response.Headers.GetValues("Ra
nge").First());
 logger.Debug("MediaUpload[{0}] - {1} Bytes were sent successfull
y", UploadUri, BytesServerReceived);
 return false;
 }
 
 var error = await Service.DeserializeError(response).ConfigureAwait(
false);
 throw new GoogleApiException(Service.Name, error.ToString());
 }
 
- /// <summary> A callback when the media was uploaded successfully. </sum
 mary>
+ /// <summary>A callback when the media was uploaded successfully.</summa
 ry>
 private void MediaCompleted(HttpResponseMessage response)
 {
 logger.Debug("MediaUpload[{0}] - media was uploaded successfully", U
ploadUri);
 ProcessResponse(response);
 BytesServerReceived = LastMediaLength;
 
 // clear the last request byte array
 LastMediaRequest = null;
 }
 
- /// <summary> Prepares the given request with the next chunk in case the
  steam length is unknown. </summary>
+ /// <summary>Prepares the given request with the next chunk in case the 
 steam length is unknown.</summary>
 private void PrepareNextChunkUnknownSize(HttpRequestMessage request, Str
eam stream,
 CancellationToken cancellationToken)
 {
 // We save the current request, so we would be able to resend those
bytes in case of a server error
 if (LastMediaRequest == null)
 {
 LastMediaRequest = new byte[ChunkSize];
 }
 
 LastMediaLength = 0;
@@ skipping 47 matching lines @@
 CachedByte = null;
 }
 }
 
 // set Content-Length and Content-Range
 var byteArrayContent = new ByteArrayContent(LastMediaRequest, 0, Las
tMediaLength);
 byteArrayContent.Headers.Add("Content-Range", GetContentRangeHeader(
BytesServerReceived, LastMediaLength));
 request.Content = byteArrayContent;
 }
 
- /// <summary> Prepares the given request with the next chunk in case the
  steam length is known. </summary>
+ /// <summary>Prepares the given request with the next chunk in case the 
 steam length is known.</summary>
 private void PrepareNextChunkKnownSize(HttpRequestMessage request, Strea
m stream,
 CancellationToken cancellationToken)
 {
 int chunkSize = (int)Math.Min(StreamLength - BytesServerReceived, (l
ong)ChunkSize);
 
 // stream length is known and it supports seek and position operatio
ns.
 // We can change the stream position and read bytes from the last po
int
 byte[] buffer = new byte[Math.Min(chunkSize, BufferSize)];
 
 // if the number of bytes received by the server isn't equal to the
amount of bytes the client sent, we·
@@ skipping 18 matching lines @@
 }
 
 // set the stream position to beginning and wrap it with stream cont
ent
 ms.Position = 0;
 request.Content = new StreamContent(ms);
 request.Content.Headers.Add("Content-Range", GetContentRangeHeader(B
ytesServerReceived, chunkSize));
 
 LastMediaLength = chunkSize;
 }
 
- /// <summary> Returns the next byte index need to be sent. </summary>
+ /// <summary>Returns the next byte index need to be sent.</summary>
 private long GetNextByte(string range)
 {
 return long.Parse(range.Substring(range.IndexOf('-') 1)) 1;
 }
 
 /// <summary>
 /// Build a content range header of the form: "bytes X-Y/T" where:
 /// <list type="">
 /// <item>X is the first byte being sent.</item>
 /// <item>Y is the last byte in the range being sent (inclusive).</item>
@@ skipping 18 matching lines @@
 {
 return ZeroByteContentRangeHeader;
 }
 else
 {
 long chunkEnd = chunkStart chunkSize - 1;
 return String.Format("bytes {0}-{1}/{2}", chunkStart, chunkEnd,
strLength);
 }
 }
 
- /// <summary> Creates a request to initialize a request. </summary>
+ /// <summary>Creates a request to initialize a request.</summary>
 private HttpRequestMessage CreateInitializeRequest()
 {
 var builder = new RequestBuilder()
 {
 BaseUri = new Uri(Service.BaseUri),
 Path = Path,
 Method = HttpMethod,
 };
 
 // init parameters
@@ skipping 89 matching lines @@
 /// <remarks>
 /// This property will be set during upload. The <see cref="ResponseRece
ived"/> event
 /// is triggered when this has been set.
 /// </remarks>
 public TResponse ResponseBody { get; private set; }
 
 #endregion // Properties
 
 #region Events
 
- /// <summary> Event which is called when the response metadata is proces
 sed. </summary>
+ /// <summary>Event which is called when the response metadata is process
 ed.</summary>
 public event Action<TResponse> ResponseReceived;
 
 #endregion // Events
 
 #region Overrides
 
- /// <summary> Process the response body </summary>
+ /// <summary>Process the response body </summary>
 protected override void ProcessResponse(HttpResponseMessage response)
 {
 base.ProcessResponse(response);
 ResponseBody = Service.DeserializeResponse<TResponse>(response).Resu
lt;
 
 if (ResponseReceived != null)
 ResponseReceived(ResponseBody);
 }
 
 #endregion // Overrides
 }
 }