Derived uploader for signed URLs

Author: evildour

apis/Google.Cloud.Storage.V1/Google.Cloud.Storage.V1.IntegrationTests/UrlSignerTest.cs

@@ -524,7 +524,7 @@ private void ResumableUploadTest_InitDelayTest()
                     url = _fixture.UrlSigner.Sign(bucket, name, duration, UrlSigner.ResumableHttpMethod);
 
                     // Verify that the URL works initially.
-                    var uploader = TmpResumableUpload.CreateFromSignedUrl(url, new MemoryStream(data));
+                    var uploader = SignedUrlResumableUpload.Create(url, new MemoryStream(data));
                     var progress = await uploader.UploadAsync();
                     Assert.Equal(UploadStatus.Completed, progress.Status);
 
@@ -537,7 +537,7 @@ private void ResumableUploadTest_InitDelayTest()
                 },
                 afterDelay: async () =>
                 {
-                    var uploader = TmpResumableUpload.CreateFromSignedUrl(url, new MemoryStream(data));
+                    var uploader = SignedUrlResumableUpload.Create(url, new MemoryStream(data));
 
                     // Verify that the URL no longer works.
                     var progress = await uploader.UploadAsync();
@@ -563,7 +563,7 @@ private void ResumableUploadResumeTest_InitDelayTest()
                 beforeDelay: async duration =>
                 {
                     url = _fixture.UrlSigner.Sign(bucket, name, duration, UrlSigner.ResumableHttpMethod);
-                    var sessionUri = await TmpResumableUpload.GetSessionUriAsync(url);
+                    var sessionUri = await SignedUrlResumableUpload.InitiateSessionAsync(url);
 
                     // Verify that the URL works initially.
                     var uploader = TmpResumableUpload.CreateFromSessionUri(sessionUri, new MemoryStream(data));
@@ -578,7 +578,7 @@ private void ResumableUploadResumeTest_InitDelayTest()
                 afterDelay: async () =>
                 {
                     // Verify that the URL no longer works.
-                    await Assert.ThrowsAsync<GoogleApiException>(() => TmpResumableUpload.GetSessionUriAsync(url));
+                    await Assert.ThrowsAsync<GoogleApiException>(() => SignedUrlResumableUpload.InitiateSessionAsync(url));
 
                     var obj = await _fixture.Client.ListObjectsAsync(bucket, name).FirstOrDefault(o => o.Name == name);
                     Assert.Null(obj);
@@ -621,16 +621,16 @@ private void ResumableUploadWithCustomerSuppliedEncryptionKeysTest_InitDelayTest
                         });
 
                     // Verify that the URL works initially.
-                    var uploader = TmpResumableUpload.CreateFromSignedUrl(
+                    var uploader = SignedUrlResumableUpload.Create(
                         url,
                         new MemoryStream(data),
-                        new ResumableUploadSessionOptions
+                        new ResumableUploadOptions
                         {
-                            ModifySessionUriRequest = sessionUriRequest =>
+                            ModifySessionInitiationRequest = initiateRequest =>
                             {
-                                sessionUriRequest.Headers.Add("x-goog-encryption-algorithm", "AES256");
-                                sessionUriRequest.Headers.Add("x-goog-encryption-key", key);
-                                sessionUriRequest.Headers.Add("x-goog-encryption-key-sha256", hash);
+                                initiateRequest.Headers.Add("x-goog-encryption-algorithm", "AES256");
+                                initiateRequest.Headers.Add("x-goog-encryption-key", key);
+                                initiateRequest.Headers.Add("x-goog-encryption-key-sha256", hash);
                             }
                         });
                     var progress = await uploader.UploadAsync();
@@ -661,16 +661,16 @@ await Assert.ThrowsAsync<GoogleApiException>(
                 },
                 afterDelay: async () =>
                 {
-                    var uploader = TmpResumableUpload.CreateFromSignedUrl(
+                    var uploader = SignedUrlResumableUpload.Create(
                         url,
                         new MemoryStream(data),
-                        new ResumableUploadSessionOptions
+                        new ResumableUploadOptions
                         {
-                            ModifySessionUriRequest = sessionUriRequest =>
+                            ModifySessionInitiationRequest = initiateRequest =>
                             {
-                                sessionUriRequest.Headers.Add("x-goog-encryption-algorithm", "AES256");
-                                sessionUriRequest.Headers.Add("x-goog-encryption-key", key);
-                                sessionUriRequest.Headers.Add("x-goog-encryption-key-sha256", hash);
+                                initiateRequest.Headers.Add("x-goog-encryption-algorithm", "AES256");
+                                initiateRequest.Headers.Add("x-goog-encryption-key", key);
+                                initiateRequest.Headers.Add("x-goog-encryption-key-sha256", hash);
                             }
                         });
 

apis/Google.Cloud.Storage.V1/Google.Cloud.Storage.V1/RemoveMe/ResumableUpload.cs

@@ -35,121 +35,116 @@ limitations under the License.
 
 namespace Google.Apis.Upload
 {
-    public sealed class ResumableUploadSessionOptions
+    /// <summary>
+    /// Options for <c>ResumableUpload</c> operations.
+    /// </summary>
+    public sealed class ResumableUploadOptions
     {
+        /// <summary>
+        /// Gets or sets the HTTP client to use when starting the upload sessions and uploading data.
+        /// </summary>
         public HttpClient HttpClient { get; set; }
 
         internal ConfigurableHttpClient ConfigurableHttpClient { get { return HttpClient as ConfigurableHttpClient; } }
 
-        public Action<HttpRequestMessage> ModifySessionUriRequest { get; set; }
+        /// <summary>
+        /// Gets or sets the callback for modifying the session initiation request.
+        /// See https://cloud.google.com/storage/docs/json_api/v1/how-tos/resumable-upload#start-resumable for more information.
+        /// </summary>
+        /// <remarks>
+        /// Note: If these options are used with a <see cref="TmpResumableUpload"/> created using <see cref="TmpResumableUpload.CreateFromSessionUri"/>,
+        /// this property will be ignored as the session has already been initiated.
+        /// </remarks>
+        public Action<HttpRequestMessage> ModifySessionInitiationRequest { get; set; }
 
+        /// <summary>
+        /// Gets or sets the serializer to use when parsing error responses.
+        /// </summary>
         public ISerializer Serializer { get; set; }
 
+        /// <summary>
+        /// Gets or sets the name of the service performing the upload.
+        /// </summary>
+        /// <remarks>
+        /// This will be used to set the <see cref="GoogleApiException.ServiceName"/> in the event of an error.
+        /// </remarks>
         public string ServiceName { get; set; }
     }
 
+    /// <summary>
+    /// Media upload which uses Google's resumable media upload protocol to upload data.
+    /// </summary>
+    /// <remarks>
+    /// See: https://developers.google.com/drive/manage-uploads#resumable for more information on the protocol.
+    /// </remarks>
     public class TmpResumableUpload
     {
-        protected ConfigurableHttpClient HttpClient { get; }
-
-        private ResumableUploadSessionOptions Options { get; }
-
-        private string SignedUrl { get; set; }
+        internal ConfigurableHttpClient HttpClient { get; }
 
+        /// <summary>
+        /// Gets the options used to control the resumable upload.
+        /// </summary>
+        protected ResumableUploadOptions Options { get; }
 
-        protected TmpResumableUpload(Stream contentStream, ResumableUploadSessionOptions options)
+        /// <summary>
+        /// Creates a <see cref="TmpResumableUpload"/> instance.
+        /// </summary>
+        /// <param name="contentStream">The data to be uploaded.</param>
+        /// <param name="options">The options for the upload operation.</param>
+        protected TmpResumableUpload(Stream contentStream, ResumableUploadOptions options)
         {
+            contentStream.ThrowIfNull(nameof(contentStream));
             ContentStream = contentStream;
             HttpClient = options?.ConfigurableHttpClient ?? new ConfigurableHttpClient(new ConfigurableMessageHandler(new HttpClientHandler()));
             Options = options;
         }
 
-        private TmpResumableUpload(string signedUrl, Stream contentStream, ResumableUploadSessionOptions options)
-            : this(contentStream, options)
-        {
-            SignedUrl = signedUrl;
-        }
-
-        private TmpResumableUpload(Uri sessionUri, Stream contentStream, ResumableUploadSessionOptions options)
+        private TmpResumableUpload(Uri sessionUri, Stream contentStream, ResumableUploadOptions options)
             : this(contentStream, options)
         {
             UploadUri = sessionUri;
         }
 
         /// <summary>
-        /// Initializes the resumable upload by calling the resumable rest interface to get a unique upload location.
-        /// See https://developers.google.com/drive/manage-uploads#start-resumable for more details.
+        /// Initiates the resumable upload session and returns the session URI.
+        /// See https://developers.google.com/drive/manage-uploads#start-resumable and
+        /// https://cloud.google.com/storage/docs/json_api/v1/how-tos/resumable-upload#start-resumable for more information.
         /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>
-        /// The unique upload location for this upload, returned in the Location header
+        /// The task containing the session URI to use for the resumable upload.
         /// </returns>
-        protected virtual async Task<Uri> GetSessionUriAsync(CancellationToken cancellationToken)
+        protected virtual Task<Uri> InitiateSessionAsync(CancellationToken cancellationToken)
         {
             if (UploadUri != null)
             {
-                return UploadUri;
-            }
-
-            if (SignedUrl != null)
-            {
-                return await GetSessionUriAsync(SignedUrl, Options, cancellationToken);
+                return Task.FromResult(UploadUri);
             }
-
-            throw new InvalidOperationException($"Could not obtain a session URI with the information in the {nameof(TmpResumableUpload)} instance.");
+            
+            throw new InvalidOperationException($"Could not initiate the resumable upload session with the information in the {this.GetType().Name} instance.");
         }
 
+        /// <summary>
+        /// Creates a <see cref="TmpResumableUpload"/> instance for a resumable upload session which has already been initiated.
+        /// </summary>
+        /// <remarks>
+        /// See https://cloud.google.com/storage/docs/json_api/v1/how-tos/resumable-upload#start-resumable for more information about initiating
+        /// resumable upload sessions and saving the session URI.
+        /// </remarks>
+        /// <param name="sessionUri">The session URI of the resumable upload session.</param>
+        /// <param name="contentStream">The data to be uploaded.</param>
+        /// <param name="options">The options for the upload operation.</param>
+        /// <returns>The instance which can be used to upload the specified content.</returns>
         public static TmpResumableUpload CreateFromSessionUri(
             Uri sessionUri,
             Stream contentStream,
-            ResumableUploadSessionOptions options = null)
+            ResumableUploadOptions options = null)
         {
             sessionUri.ThrowIfNull(nameof(sessionUri));
             return new TmpResumableUpload(sessionUri, contentStream, options);
         }
-
-        public static TmpResumableUpload CreateFromSignedUrl(
-            string signedUrl,
-            Stream contentStream,
-            ResumableUploadSessionOptions options = null)
-        {
-            signedUrl.ThrowIfNull(nameof(signedUrl));
-            return new TmpResumableUpload(signedUrl, contentStream, options);
-        }
-
-        public static Uri GetSessionUri(string signedUrl, ResumableUploadSessionOptions options = null) =>
-            GetResult(token => GetSessionUriAsync(signedUrl, options));
-
-        public static async Task<Uri> GetSessionUriAsync(
-            string signedUrl,
-            ResumableUploadSessionOptions options = null,
-            CancellationToken cancellationToken = default(CancellationToken))
-        {
-            var httpClient = options?.HttpClient ?? new HttpClient();
-            var request = new HttpRequestMessage(HttpMethod.Post, signedUrl);
-            request.Headers.Add("x-goog-resumable", "start");
-            options?.ModifySessionUriRequest?.Invoke(request);
-            var result = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
-            if (!result.IsSuccessStatusCode)
-            {
-                throw await MediaApiErrorHandling.ExceptionForResponseAsync(options?.Serializer, options?.ServiceName, result).ConfigureAwait(false);
-            }
-            return result.Headers.Location;
-        }
-
-        private static T GetResult<T>(Func<CancellationToken, Task<T>> operation)
-        {
-            try
-            {
-                return operation(CancellationToken.None).Result;
-            }
-            catch (AggregateException e)
-            {
-                throw e.InnerExceptions.FirstOrDefault() ?? e;
-            }
-        }
-
-
-
+        
+        
         /// <summary>The class logger.</summary>
         protected static ILogger Logger { get; } = ApplicationContext.Logger.ForType<TmpResumableUpload>();
 
@@ -273,7 +268,7 @@ public async Task<IUploadProgress> UploadAsync(CancellationToken cancellationTok
 
             try
             {
-                UploadUri = await GetSessionUriAsync(cancellationToken).ConfigureAwait(false);
+                UploadUri = await InitiateSessionAsync(cancellationToken).ConfigureAwait(false);
                 if (ContentStream.CanSeek)
                 {
                     SendUploadSessionData(new ResumeableUploadSessionData(UploadUri));
@@ -376,6 +371,11 @@ protected async Task<bool> HandleResponse(HttpResponseMessage response)
             throw await ExceptionForResponseAsync(response).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Creates a <see cref="GoogleApiException"/> instance using the error response from the server.
+        /// </summary>
+        /// <param name="response">The error response.</param>
+        /// <returns>An exception which can be thrown by the caller.</returns>
         protected Task<GoogleApiException> ExceptionForResponseAsync(HttpResponseMessage response)
         {
             return MediaApiErrorHandling.ExceptionForResponseAsync(Options?.Serializer, Options?.ServiceName, response);
@@ -662,7 +662,7 @@ public async Task<IUploadProgress> ResumeAsync(Uri uploadUri, CancellationToken
         /// were successfully uploaded before the error occurred.
         /// See https://developers.google.com/drive/manage-uploads#resume-upload for more details.
         /// </summary>
-        protected sealed class ServerErrorCallback : IHttpUnsuccessfulResponseHandler, IHttpExceptionHandler, IDisposable
+        private sealed class ServerErrorCallback : IHttpUnsuccessfulResponseHandler, IHttpExceptionHandler, IDisposable
         {
             private TmpResumableUpload Owner { get; set; }
 
@@ -730,7 +730,7 @@ public void Dispose()
         #region Progress Monitoring
 
         /// <summary>Class that communicates the progress of resumable uploads to a container.</summary>
-        protected sealed class ResumableUploadProgress : IUploadProgress
+        private sealed class ResumableUploadProgress : IUploadProgress
         {
             /// <summary>
             /// Create a ResumableUploadProgress instance.
@@ -764,12 +764,12 @@ public ResumableUploadProgress(Exception exception, long bytesSent)
         /// Current state of progress of the upload.
         /// </summary>
         /// <seealso cref="ProgressChanged"/>
-        protected ResumableUploadProgress Progress { get; set; }
+        private ResumableUploadProgress Progress { get; set; }
 
         /// <summary>
         /// Updates the current progress and call the <see cref="ProgressChanged"/> event to notify listeners.
         /// </summary>
-        protected void UpdateProgress(ResumableUploadProgress progress)
+        private void UpdateProgress(ResumableUploadProgress progress)
         {
             Progress = progress;
             ProgressChanged?.Invoke(progress);
@@ -872,7 +872,7 @@ public abstract class TmpResumableUpload<TRequest> : TmpResumableUpload
         /// </remarks>
         protected TmpResumableUpload(IClientService service, string path, string httpMethod, Stream contentStream,
             string contentType)
-            : base(contentStream, new ResumableUploadSessionOptions {
+            : base(contentStream, new ResumableUploadOptions {
                 HttpClient = service.HttpClient,
                 Serializer = service.Serializer,
                 ServiceName = service.Name
@@ -914,16 +914,11 @@ protected TmpResumableUpload(IClientService service, string path, string httpMet
 
         #endregion // Properties
 
-        /// <summary>
-        /// Initializes the resumable upload by calling the resumable rest interface to get a unique upload location.
-        /// See https://developers.google.com/drive/manage-uploads#start-resumable for more details.
-        /// </summary>
-        /// <returns>
-        /// The unique upload location for this upload, returned in the Location header
-        /// </returns>
-        protected override async Task<Uri> GetSessionUriAsync(CancellationToken cancellationToken)
+        /// <inheritdoc/>
+        protected override async Task<Uri> InitiateSessionAsync(CancellationToken cancellationToken)
         {
             HttpRequestMessage request = CreateInitializeRequest();
+            Options?.ModifySessionInitiationRequest?.Invoke(request);
             var response = await Service.HttpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
 
             if (!response.IsSuccessStatusCode)