Add DownloadInitiated, Failed and Completed events

stack-info: PR: #4079, branch: GarrettBeatty/stacked/10

Author: GarrettBeatty

generator/.DevConfigs/9d07dc1e-d82d-4f94-8700-c7b57f872123.json

@@ -0,0 +1,11 @@
+{
+  "services": [
+    {
+      "serviceName": "S3",
+      "type": "minor",
+      "changeLogMessages": [
+      "Added DownloadInitiatedEvent, DownloadCompletedEvent, and DownloadFailedEvent for downloads."
+      ]
+    }
+  ]
+}

sdk/src/Services/S3/Custom/Model/GetObjectResponse.cs

@@ -25,6 +25,7 @@
 using Amazon.S3.Model.Internal.MarshallTransformations;
 using Amazon.S3;
 using Amazon.Runtime.Internal;
+using Amazon.S3.Transfer;
 
 namespace Amazon.S3.Model
 {
@@ -1042,5 +1043,10 @@ internal WriteObjectProgressArgs(string bucketName, string key, string filePath,
         /// True if writing is complete
         /// </summary>
         public bool IsCompleted { get; private set; }
+
+        /// <summary>
+        /// The original TransferUtilityDownloadRequest created by the user.
+        /// </summary>
+        public TransferUtilityDownloadRequest Request { get; internal set; }
     }  
 }

sdk/src/Services/S3/Custom/Transfer/Internal/DownloadCommand.cs

@@ -62,6 +62,34 @@ static Logger Logger
 
         IAmazonS3 _s3Client;
         TransferUtilityDownloadRequest _request;
+        long _totalTransferredBytes;
+
+        #region Event Firing Methods
+
+        private void FireTransferInitiatedEvent()
+        {
+            var transferInitiatedEventArgs = new DownloadInitiatedEventArgs(_request, _request.FilePath);
+            _request.OnRaiseTransferInitiatedEvent(transferInitiatedEventArgs);
+        }
+
+        private void FireTransferCompletedEvent(TransferUtilityDownloadResponse response, string filePath, long transferredBytes, long totalBytes)
+        {
+            var transferCompletedEventArgs = new DownloadCompletedEventArgs(
+                _request, 
+                response, 
+                filePath, 
+                transferredBytes, 
+                totalBytes);
+            _request.OnRaiseTransferCompletedEvent(transferCompletedEventArgs);
+        }
+
+        private void FireTransferFailedEvent(string filePath, long transferredBytes, long totalBytes = -1)
+        {
+            var eventArgs = new DownloadFailedEventArgs(this._request, filePath, transferredBytes, totalBytes);
+            this._request.OnRaiseTransferFailedEvent(eventArgs);
+        }
+
+        #endregion
 
         internal DownloadCommand(IAmazonS3 s3Client, TransferUtilityDownloadRequest request)
         {
@@ -89,6 +117,12 @@ private void ValidateRequest()
 
         void OnWriteObjectProgressEvent(object sender, WriteObjectProgressArgs e)
         {
+            // Keep track of the total transferred bytes so that we can also return this value in case of failure
+            Interlocked.Add(ref _totalTransferredBytes, e.IncrementTransferred);
+            
+            // Set the Request property to enable access to the original download request
+            e.Request = this._request;
+            
             this._request.OnRaiseProgressEvent(e);
         }
 

sdk/src/Services/S3/Custom/Transfer/Internal/_async/DownloadCommand.async.cs

@@ -33,12 +33,19 @@ internal partial class DownloadCommand : BaseCommand<TransferUtilityDownloadResp
         public override async Task<TransferUtilityDownloadResponse> ExecuteAsync(CancellationToken cancellationToken)
         {
             ValidateRequest();
+            
+            FireTransferInitiatedEvent();
+            
             GetObjectRequest getRequest = ConvertToGetObjectRequest(this._request);
 
             var maxRetries = _s3Client.Config.MaxErrorRetry;
             var retries = 0;
             bool shouldRetry = false;
             string mostRecentETag = null;
+            TransferUtilityDownloadResponse lastSuccessfulMappedResponse = null;
+            long? totalBytesFromResponse = null; // Track total bytes once we have response headers
+            long totalTransferredBytes = 0;
+            
             do
             {
                 shouldRetry = false;
@@ -54,12 +61,16 @@ public override async Task<TransferUtilityDownloadResponse> ExecuteAsync(Cancell
                     using (var response = await this._s3Client.GetObjectAsync(getRequest, cancellationToken)
                         .ConfigureAwait(continueOnCapturedContext: false))
                     {
+                        // Capture total bytes from response headers as soon as we get them
+                        totalBytesFromResponse = response.ContentLength;
+                        
                         if (!string.IsNullOrEmpty(mostRecentETag) && !string.Equals(mostRecentETag, response.ETag))
                         {
                             //if the eTag changed, we need to retry from the start of the file
                             mostRecentETag = response.ETag;
                             getRequest.ByteRange = null;
                             retries = 0;
+                            Interlocked.Exchange(ref _totalTransferredBytes, 0);
                             shouldRetry = true;
                             WaitBeforeRetry(retries);
                             continue;
@@ -101,6 +112,9 @@ await response.WriteResponseStreamToFileAsync(this._request.FilePath, false, can
                             await response.WriteResponseStreamToFileAsync(this._request.FilePath, true, cancellationToken)
                                 .ConfigureAwait(continueOnCapturedContext: false);
                         }
+                        
+                        lastSuccessfulMappedResponse = ResponseMapper.MapGetObjectResponse(response);
+                        totalTransferredBytes = Interlocked.Read(ref _totalTransferredBytes);
                     }
                 }
                 catch (Exception exception)
@@ -109,6 +123,9 @@ await response.WriteResponseStreamToFileAsync(this._request.FilePath, true, canc
                     shouldRetry = HandleExceptionForHttpClient(exception, retries, maxRetries);
                     if (!shouldRetry)
                     {
+                        // Pass total bytes if we have them from response headers, otherwise -1 for unknown
+                        FireTransferFailedEvent(this._request.FilePath, Interlocked.Read(ref _totalTransferredBytes), totalBytesFromResponse ?? -1);
+                        
                         if (exception is IOException)
                         {
                             throw;
@@ -131,8 +148,9 @@ await response.WriteResponseStreamToFileAsync(this._request.FilePath, true, canc
                 WaitBeforeRetry(retries);
             } while (shouldRetry);
 
-            // TODO map and return response
-            return new TransferUtilityDownloadResponse();
+            FireTransferCompletedEvent(lastSuccessfulMappedResponse, this._request.FilePath, totalTransferredBytes, totalBytesFromResponse ?? -1);
+
+            return lastSuccessfulMappedResponse;
         }
 
         private static bool HandleExceptionForHttpClient(Exception exception, int retries, int maxRetries)