cocoapods-catalyst-validator 0.1.0.beta.1

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCCTLibrary/GDTCCTUploadOperation.m

@@ -0,0 +1,573 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "GoogleDataTransport/GDTCCTLibrary/Private/GDTCCTUploadOperation.h"
+
+#if __has_include(<FBLPromises/FBLPromises.h>)
+#import <FBLPromises/FBLPromises.h>
+#else
+#import "FBLPromises.h"
+#endif
+
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORPlatform.h"
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORRegistrar.h"
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORStorageProtocol.h"
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORUploadBatch.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREvent.h"
+
+#import <nanopb/pb.h>
+#import <nanopb/pb_decode.h>
+#import <nanopb/pb_encode.h>
+
+#import <GoogleUtilities/GULURLSessionDataResponse.h>
+#import <GoogleUtilities/NSURLSession+GULPromises.h>
+#import "GoogleDataTransport/GDTCCTLibrary/Private/GDTCCTCompressionHelper.h"
+#import "GoogleDataTransport/GDTCCTLibrary/Private/GDTCCTNanopbHelpers.h"
+
+#import "GoogleDataTransport/GDTCCTLibrary/Protogen/nanopb/cct.nanopb.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef GDTCOR_VERSION
+#define STR(x) STR_EXPAND(x)
+#define STR_EXPAND(x) #x
+static NSString *const kGDTCCTSupportSDKVersion = @STR(GDTCOR_VERSION);
+#else
+static NSString *const kGDTCCTSupportSDKVersion = @"UNKNOWN";
+#endif  // GDTCOR_VERSION
+
+typedef void (^GDTCCTUploaderURLTaskCompletion)(NSNumber *batchID,
+                                                NSSet<GDTCOREvent *> *_Nullable events,
+                                                NSData *_Nullable data,
+                                                NSURLResponse *_Nullable response,
+                                                NSError *_Nullable error);
+
+typedef void (^GDTCCTUploaderEventBatchBlock)(NSNumber *_Nullable batchID,
+                                              NSSet<GDTCOREvent *> *_Nullable events);
+
+@interface GDTCCTUploadOperation () <NSURLSessionDelegate>
+
+/// The properties to store parameters passed in the initializer. See the initialized docs for
+/// details.
+@property(nonatomic, readonly) GDTCORTarget target;
+@property(nonatomic, readonly) GDTCORUploadConditions conditions;
+@property(nonatomic, readonly) NSURL *uploadURL;
+@property(nonatomic, readonly) id<GDTCORStoragePromiseProtocol> storage;
+@property(nonatomic, readonly) id<GDTCCTUploadMetadataProvider> metadataProvider;
+
+/** The URL session that will attempt upload. */
+@property(nonatomic) NSURLSession *uploaderSession;
+
+/// NSOperation state properties implementation.
+@property(nonatomic, readwrite, getter=isExecuting) BOOL executing;
+@property(nonatomic, readwrite, getter=isFinished) BOOL finished;
+
+@property(nonatomic, readwrite) BOOL uploadAttempted;
+
+@end
+
+@implementation GDTCCTUploadOperation
+
+- (instancetype)initWithTarget:(GDTCORTarget)target
+                    conditions:(GDTCORUploadConditions)conditions
+                     uploadURL:(NSURL *)uploadURL
+                         queue:(dispatch_queue_t)queue
+                       storage:(id<GDTCORStoragePromiseProtocol>)storage
+              metadataProvider:(id<GDTCCTUploadMetadataProvider>)metadataProvider {
+  self = [super init];
+  if (self) {
+    _uploaderQueue = queue;
+    _target = target;
+    _conditions = conditions;
+    _uploadURL = uploadURL;
+    _storage = storage;
+    _metadataProvider = metadataProvider;
+  }
+  return self;
+}
+
+- (NSURLSession *)uploaderSessionCreateIfNeeded {
+  if (_uploaderSession == nil) {
+    NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
+    _uploaderSession = [NSURLSession sessionWithConfiguration:config
+                                                     delegate:self
+                                                delegateQueue:nil];
+  }
+  return _uploaderSession;
+}
+
+- (void)uploadTarget:(GDTCORTarget)target withConditions:(GDTCORUploadConditions)conditions {
+  __block GDTCORBackgroundIdentifier backgroundTaskID = GDTCORBackgroundIdentifierInvalid;
+
+  dispatch_block_t backgroundTaskCompletion = ^{
+    // End the background task if there was one.
+    if (backgroundTaskID != GDTCORBackgroundIdentifierInvalid) {
+      [[GDTCORApplication sharedApplication] endBackgroundTask:backgroundTaskID];
+      backgroundTaskID = GDTCORBackgroundIdentifierInvalid;
+    }
+  };
+
+  backgroundTaskID = [[GDTCORApplication sharedApplication]
+      beginBackgroundTaskWithName:@"GDTCCTUploader-upload"
+                expirationHandler:^{
+                  if (backgroundTaskID != GDTCORBackgroundIdentifierInvalid) {
+                    // Cancel the upload and complete delivery.
+                    [self.currentTask cancel];
+
+                    // End the background task.
+                    backgroundTaskCompletion();
+                  }
+                }];
+
+  id<GDTCORStoragePromiseProtocol> storage = self.storage;
+
+  // 1. Check if the conditions for the target are suitable.
+  [self isReadyToUploadTarget:target conditions:conditions]
+      .thenOn(self.uploaderQueue,
+              ^id(id result) {
+                // 2. Remove previously attempted batches
+                return [storage removeAllBatchesForTarget:target deleteEvents:NO];
+              })
+      .thenOn(self.uploaderQueue,
+              ^FBLPromise<NSNumber *> *(id result) {
+                // There may be a big amount of events stored, so creating a batch may be an
+                // expensive operation.
+
+                // 3. Do a lightweight check if there are any events for the target first to
+                // finish early if there are no.
+                return [storage hasEventsForTarget:target];
+              })
+      .validateOn(self.uploaderQueue,
+                  ^BOOL(NSNumber *hasEvents) {
+                    // Stop operation if there are no events to upload.
+                    return hasEvents.boolValue;
+                  })
+      .thenOn(self.uploaderQueue,
+              ^FBLPromise<GDTCORUploadBatch *> *(id result) {
+                if (self.isCancelled) {
+                  return nil;
+                }
+
+                // 4. Fetch events to upload.
+                GDTCORStorageEventSelector *eventSelector = [self eventSelectorTarget:target
+                                                                       withConditions:conditions];
+                return [storage batchWithEventSelector:eventSelector
+                                       batchExpiration:[NSDate dateWithTimeIntervalSinceNow:600]];
+              })
+      .validateOn(self.uploaderQueue,
+                  ^BOOL(GDTCORUploadBatch *batch) {
+                    // 5. Validate batch.
+                    return batch.batchID != nil && batch.events.count > 0;
+                  })
+      .thenOn(self.uploaderQueue,
+              ^FBLPromise *(GDTCORUploadBatch *batch) {
+                // A non-empty batch has been created, consider it as an upload attempt.
+                self.uploadAttempted = YES;
+
+                // 6. Perform upload URL request.
+                return [self sendURLRequestWithBatch:batch target:target storage:storage];
+              })
+      .thenOn(self.uploaderQueue,
+              ^id(id result) {
+                // 7. Finish operation.
+                [self finishOperation];
+                backgroundTaskCompletion();
+                return nil;
+              })
+      .catchOn(self.uploaderQueue, ^(NSError *error) {
+        // TODO: Maybe report the error to the client.
+        [self finishOperation];
+        backgroundTaskCompletion();
+      });
+}
+
+#pragma mark - Upload implementation details
+
+/** Sends URL request to upload the provided batch and handle the response. */
+- (FBLPromise<NSNull *> *)sendURLRequestWithBatch:(GDTCORUploadBatch *)batch
+                                           target:(GDTCORTarget)target
+                                          storage:(id<GDTCORStoragePromiseProtocol>)storage {
+  NSNumber *batchID = batch.batchID;
+
+  // 1. Send URL request.
+  return [self sendURLRequestWithBatch:batch target:target]
+      .thenOn(
+          self.uploaderQueue,
+          ^FBLPromise<NSNull *> *(GULURLSessionDataResponse *response) {
+            // 2. Parse response and update the next upload time if can.
+            [self updateNextUploadTimeWithResponse:response forTarget:target];
+
+            // 3. Cleanup batch.
+
+            // Only retry if one of these codes is returned:
+            // 429 - Too many requests;
+            // 5xx - Server errors.
+            NSInteger statusCode = response.HTTPResponse.statusCode;
+            if (statusCode == 429 || (statusCode >= 500 && statusCode < 600)) {
+              // Move the events back to the main storage to be uploaded on the next attempt.
+              return [storage removeBatchWithID:batchID deleteEvents:NO];
+            } else {
+              if (statusCode >= 200 && statusCode <= 300) {
+                GDTCORLogDebug(@"CCT: batch %@ delivered", batchID);
+              } else {
+                GDTCORLogDebug(
+                    @"CCT: batch %@ was rejected by the server and will be deleted with all events",
+                    batchID);
+              }
+
+              // The events are either delivered or unrecoverable broken, so remove the batch with
+              // events.
+              return [storage removeBatchWithID:batch.batchID deleteEvents:YES];
+            }
+          })
+      .recoverOn(self.uploaderQueue, ^id(NSError *error) {
+        // In the case of a network error move the events back to the main storage to be uploaded on
+        // the next attempt.
+        return [storage removeBatchWithID:batchID deleteEvents:NO];
+      });
+}
+
+/** Composes and sends URL request. */
+- (FBLPromise<GULURLSessionDataResponse *> *)sendURLRequestWithBatch:(GDTCORUploadBatch *)batch
+                                                              target:(GDTCORTarget)target {
+  return [FBLPromise
+             onQueue:self.uploaderQueue
+                  do:^NSURLRequest * {
+                    // 1. Prepare URL request.
+                    NSData *requestProtoData = [self constructRequestProtoWithEvents:batch.events];
+                    NSData *gzippedData = [GDTCCTCompressionHelper gzippedData:requestProtoData];
+                    BOOL usingGzipData =
+                        gzippedData != nil && gzippedData.length < requestProtoData.length;
+                    NSData *dataToSend = usingGzipData ? gzippedData : requestProtoData;
+                    NSURLRequest *request = [self constructRequestWithURL:self.uploadURL
+                                                                forTarget:target
+                                                                     data:dataToSend];
+                    GDTCORLogDebug(@"CTT: request containing %lu events for batch: %@ for target: "
+                                   @"%ld created: %@",
+                                   (unsigned long)batch.events.count, batch.batchID, (long)target,
+                                   request);
+                    return request;
+                  }]
+      .thenOn(self.uploaderQueue,
+              ^FBLPromise<GULURLSessionDataResponse *> *(NSURLRequest *request) {
+                // 2. Send URL request.
+                return
+                    [[self uploaderSessionCreateIfNeeded] gul_dataTaskPromiseWithRequest:request];
+              })
+      .thenOn(self.uploaderQueue,
+              ^GULURLSessionDataResponse *(GULURLSessionDataResponse *response) {
+                // Invalidate session to release the delegate (which is `self`) to break the retain
+                // cycle.
+                [self.uploaderSession finishTasksAndInvalidate];
+                return response;
+              })
+      .recoverOn(self.uploaderQueue, ^id(NSError *error) {
+        // Invalidate session to release the delegate (which is `self`) to break the retain cycle.
+        [self.uploaderSession finishTasksAndInvalidate];
+        // Re-throw the error.
+        return error;
+      });
+}
+
+/** Parses server response and update next upload time for the specified target based on it. */
+- (void)updateNextUploadTimeWithResponse:(GULURLSessionDataResponse *)response
+                               forTarget:(GDTCORTarget)target {
+  GDTCORClock *futureUploadTime;
+  if (response.HTTPBody) {
+    NSError *decodingError;
+    gdt_cct_LogResponse logResponse = GDTCCTDecodeLogResponse(response.HTTPBody, &decodingError);
+    if (!decodingError && logResponse.has_next_request_wait_millis) {
+      GDTCORLogDebug(@"CCT: The backend responded asking to not upload for %lld millis from now.",
+                     logResponse.next_request_wait_millis);
+      futureUploadTime =
+          [GDTCORClock clockSnapshotInTheFuture:logResponse.next_request_wait_millis];
+    } else if (decodingError) {
+      GDTCORLogDebug(@"There was a response decoding error: %@", decodingError);
+    }
+    pb_release(gdt_cct_LogResponse_fields, &logResponse);
+  }
+
+  // If no futureUploadTime was parsed from the response body, then check
+  // [Retry-After](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header.
+  if (!futureUploadTime) {
+    NSString *retryAfterHeader = response.HTTPResponse.allHeaderFields[@"Retry-After"];
+    if (retryAfterHeader.length > 0) {
+      NSNumberFormatter *formatter = [[NSNumberFormatter alloc] init];
+      formatter.numberStyle = NSNumberFormatterDecimalStyle;
+      NSNumber *retryAfterSeconds = [formatter numberFromString:retryAfterHeader];
+      if (retryAfterSeconds != nil) {
+        uint64_t retryAfterMillis = retryAfterSeconds.unsignedIntegerValue * 1000u;
+        futureUploadTime = [GDTCORClock clockSnapshotInTheFuture:retryAfterMillis];
+      }
+    }
+  }
+
+  if (!futureUploadTime) {
+    GDTCORLogDebug(@"%@", @"CCT: The backend response failed to parse, so the next request "
+                          @"won't occur until 15 minutes from now");
+    // 15 minutes from now.
+    futureUploadTime = [GDTCORClock clockSnapshotInTheFuture:15 * 60 * 1000];
+  }
+
+  [self.metadataProvider setNextUploadTime:futureUploadTime forTarget:target];
+}
+
+#pragma mark - Private helper methods
+
+/** @return A resolved promise if is ready and a rejected promise if not. */
+- (FBLPromise<NSNull *> *)isReadyToUploadTarget:(GDTCORTarget)target
+                                     conditions:(GDTCORUploadConditions)conditions {
+  FBLPromise<NSNull *> *promise = [FBLPromise pendingPromise];
+  if ([self readyToUploadTarget:target conditions:conditions]) {
+    [promise fulfill:[NSNull null]];
+  } else {
+    NSString *reason =
+        [NSString stringWithFormat:@"Target %ld is not ready to upload with condition: %ld",
+                                   (long)target, (long)conditions];
+    [promise reject:[self genericRejectedPromiseErrorWithReason:reason]];
+  }
+  return promise;
+}
+
+// TODO: Move to a separate class/extension/file when needed in other files.
+/** Returns an error object with the specified failure reason. */
+- (NSError *)genericRejectedPromiseErrorWithReason:(NSString *)reason {
+  return [NSError errorWithDomain:@"GDTCCTUploader"
+                             code:-1
+                         userInfo:@{NSLocalizedFailureReasonErrorKey : reason}];
+}
+
+/** Returns if the specified target is ready to be uploaded based on the specified conditions. */
+- (BOOL)readyToUploadTarget:(GDTCORTarget)target conditions:(GDTCORUploadConditions)conditions {
+  // Not ready to upload with no network connection.
+  // TODO: Reconsider using reachability to prevent an upload attempt.
+  // See https://developer.apple.com/videos/play/wwdc2019/712/ (49:40) for more details.
+  if (conditions & GDTCORUploadConditionNoNetwork) {
+    GDTCORLogDebug(@"%@", @"CCT: Not ready to upload without a network connection.");
+    return NO;
+  }
+
+  // Upload events with no additional conditions if high priority.
+  if ((conditions & GDTCORUploadConditionHighPriority) == GDTCORUploadConditionHighPriority) {
+    GDTCORLogDebug(@"%@", @"CCT: a high priority event is allowing an upload");
+    return YES;
+  }
+
+  // Check next upload time for the target.
+  BOOL isAfterNextUploadTime = YES;
+  GDTCORClock *nextUploadTime = [self.metadataProvider nextUploadTimeForTarget:target];
+  if (nextUploadTime) {
+    isAfterNextUploadTime = [[GDTCORClock snapshot] isAfter:nextUploadTime];
+  }
+
+  if (isAfterNextUploadTime) {
+    GDTCORLogDebug(@"CCT: can upload to target %ld because the request wait time has transpired",
+                   (long)target);
+  } else {
+    GDTCORLogDebug(@"CCT: can't upload to target %ld because the backend asked to wait",
+                   (long)target);
+  }
+
+  return isAfterNextUploadTime;
+}
+
+/** Constructs data given an upload package.
+ *
+ * @param events The events used to construct the request proto bytes.
+ * @return Proto bytes representing a gdt_cct_LogRequest object.
+ */
+- (nonnull NSData *)constructRequestProtoWithEvents:(NSSet<GDTCOREvent *> *)events {
+  // Segment the log events by log type.
+  NSMutableDictionary<NSString *, NSMutableSet<GDTCOREvent *> *> *logMappingIDToLogSet =
+      [[NSMutableDictionary alloc] init];
+  [events enumerateObjectsUsingBlock:^(GDTCOREvent *_Nonnull event, BOOL *_Nonnull stop) {
+    NSMutableSet *logSet = logMappingIDToLogSet[event.mappingID];
+    logSet = logSet ? logSet : [[NSMutableSet alloc] init];
+    [logSet addObject:event];
+    logMappingIDToLogSet[event.mappingID] = logSet;
+  }];
+
+  gdt_cct_BatchedLogRequest batchedLogRequest =
+      GDTCCTConstructBatchedLogRequest(logMappingIDToLogSet);
+
+  NSData *data = GDTCCTEncodeBatchedLogRequest(&batchedLogRequest);
+  pb_release(gdt_cct_BatchedLogRequest_fields, &batchedLogRequest);
+  return data ? data : [[NSData alloc] init];
+}
+
+/** Constructs a request to the given URL and target with the specified request body data.
+ *
+ * @param target The target backend to send the request to.
+ * @param data The request body data.
+ * @return A new NSURLRequest ready to be sent to FLL.
+ */
+- (nullable NSURLRequest *)constructRequestWithURL:(NSURL *)URL
+                                         forTarget:(GDTCORTarget)target
+                                              data:(NSData *)data {
+  if (data == nil || data.length == 0) {
+    GDTCORLogDebug(@"There was no data to construct a request for target %ld.", (long)target);
+    return nil;
+  }
+
+  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:URL];
+  NSString *targetString;
+  switch (target) {
+    case kGDTCORTargetCCT:
+      targetString = @"cct";
+      break;
+
+    case kGDTCORTargetFLL:
+      targetString = @"fll";
+      break;
+
+    case kGDTCORTargetCSH:
+      targetString = @"csh";
+      break;
+    case kGDTCORTargetINT:
+      targetString = @"int";
+      break;
+
+    default:
+      targetString = @"unknown";
+      break;
+  }
+  NSString *userAgent =
+      [NSString stringWithFormat:@"datatransport/%@ %@support/%@ apple/", kGDTCORVersion,
+                                 targetString, kGDTCCTSupportSDKVersion];
+
+  [request setValue:[self.metadataProvider APIKeyForTarget:target]
+      forHTTPHeaderField:@"X-Goog-Api-Key"];
+
+  if ([GDTCCTCompressionHelper isGzipped:data]) {
+    [request setValue:@"gzip" forHTTPHeaderField:@"Content-Encoding"];
+  }
+  [request setValue:@"application/x-protobuf" forHTTPHeaderField:@"Content-Type"];
+  [request setValue:@"gzip" forHTTPHeaderField:@"Accept-Encoding"];
+  [request setValue:userAgent forHTTPHeaderField:@"User-Agent"];
+  request.HTTPMethod = @"POST";
+  [request setHTTPBody:data];
+  return request;
+}
+
+/** Creates and returns a storage event selector for the specified target and conditions. */
+- (GDTCORStorageEventSelector *)eventSelectorTarget:(GDTCORTarget)target
+                                     withConditions:(GDTCORUploadConditions)conditions {
+  if ((conditions & GDTCORUploadConditionHighPriority) == GDTCORUploadConditionHighPriority) {
+    return [GDTCORStorageEventSelector eventSelectorForTarget:target];
+  }
+  NSMutableSet<NSNumber *> *qosTiers = [[NSMutableSet alloc] init];
+  if (conditions & GDTCORUploadConditionWifiData) {
+    [qosTiers addObjectsFromArray:@[
+      @(GDTCOREventQoSFast), @(GDTCOREventQoSWifiOnly), @(GDTCOREventQosDefault),
+      @(GDTCOREventQoSTelemetry), @(GDTCOREventQoSUnknown)
+    ]];
+  }
+  if (conditions & GDTCORUploadConditionMobileData) {
+    [qosTiers addObjectsFromArray:@[ @(GDTCOREventQoSFast), @(GDTCOREventQosDefault) ]];
+  }
+
+  return [[GDTCORStorageEventSelector alloc] initWithTarget:target
+                                                   eventIDs:nil
+                                                 mappingIDs:nil
+                                                   qosTiers:qosTiers];
+}
+
+#pragma mark - NSURLSessionDelegate
+
+- (void)URLSession:(NSURLSession *)session
+                          task:(NSURLSessionTask *)task
+    willPerformHTTPRedirection:(NSHTTPURLResponse *)response
+                    newRequest:(NSURLRequest *)request
+             completionHandler:(void (^)(NSURLRequest *_Nullable))completionHandler {
+  if (!completionHandler) {
+    return;
+  }
+  if (response.statusCode == 302 || response.statusCode == 301) {
+    NSURLRequest *newRequest = [self constructRequestWithURL:request.URL
+                                                   forTarget:kGDTCORTargetCCT
+                                                        data:task.originalRequest.HTTPBody];
+    completionHandler(newRequest);
+  } else {
+    completionHandler(request);
+  }
+}
+
+#pragma mark - NSOperation methods
+
+@synthesize executing = _executing;
+@synthesize finished = _finished;
+
+- (BOOL)isFinished {
+  @synchronized(self) {
+    return _finished;
+  }
+}
+
+- (BOOL)isExecuting {
+  @synchronized(self) {
+    return _executing;
+  }
+}
+
+- (BOOL)isAsynchronous {
+  return YES;
+}
+
+- (void)startOperation {
+  @synchronized(self) {
+    [self willChangeValueForKey:@"isExecuting"];
+    [self willChangeValueForKey:@"isFinished"];
+    self->_executing = YES;
+    self->_finished = NO;
+    [self didChangeValueForKey:@"isExecuting"];
+    [self didChangeValueForKey:@"isFinished"];
+  }
+}
+
+- (void)finishOperation {
+  @synchronized(self) {
+    [self willChangeValueForKey:@"isExecuting"];
+    [self willChangeValueForKey:@"isFinished"];
+    self->_executing = NO;
+    self->_finished = YES;
+    [self didChangeValueForKey:@"isExecuting"];
+    [self didChangeValueForKey:@"isFinished"];
+  }
+}
+
+- (void)start {
+  [self startOperation];
+
+  GDTCORLogDebug(@"Upload operation started: %@", self);
+  [self uploadTarget:self.target withConditions:self.conditions];
+}
+
+- (void)cancel {
+  @synchronized(self) {
+    [super cancel];
+
+    // If the operation hasn't been started we can set `isFinished = YES` straight away.
+    if (!_executing) {
+      _executing = NO;
+      _finished = YES;
+    }
+  }
+}
+
+@end
+
+NS_ASSUME_NONNULL_END