blob: bd7cd3b25ea0efb74d4bb5bb32fa448a12f71227 [file] [log] [blame]
/* Copyright (c) 2010 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
* 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.
*/
//
// GTMHTTPUploadFetcher.m
//
#if (!GDATA_REQUIRE_SERVICE_INCLUDES) || GDATA_INCLUDE_DOCS_SERVICE || \
GDATA_INCLUDE_YOUTUBE_SERVICE || GDATA_INCLUDE_PHOTOS_SERVICE
#import "GTMHTTPUploadFetcher.h"
static NSUInteger const kQueryServerForOffset = NSUIntegerMax;
@interface GTMHTTPFetcher (ProtectedMethods)
@property (readwrite, retain) NSData *downloadedData;
- (void)releaseCallbacks;
- (void)stopFetchReleasingCallbacks:(BOOL)shouldReleaseCallbacks;
- (void)connectionDidFinishLoading:(NSURLConnection *)connection;
- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error;
@end
@interface GTMHTTPUploadFetcher ()
+ (GTMHTTPUploadFetcher *)uploadFetcherWithRequest:(NSURLRequest *)request
fetcherService:(GTMHTTPFetcherService *)fetcherService;
- (void)setLocationURL:(NSURL *)location
uploadData:(NSData *)data
uploadFileHandle:(NSFileHandle *)fileHandle
uploadMIMEType:(NSString *)uploadMIMEType
chunkSize:(NSUInteger)chunkSize;
- (void)uploadNextChunkWithOffset:(NSUInteger)offset;
- (void)uploadNextChunkWithOffset:(NSUInteger)offset
fetcherProperties:(NSMutableDictionary *)props;
- (void)destroyChunkFetcher;
- (void)handleResumeIncompleteStatusForChunkFetcher:(GTMHTTPFetcher *)chunkFetcher;
- (void)uploadFetcher:(GTMHTTPFetcher *)fetcher
didSendBytes:(NSInteger)bytesSent
totalBytesSent:(NSInteger)totalBytesSent
totalBytesExpectedToSend:(NSInteger)totalBytesExpected;
- (void)reportProgressManually;
- (NSUInteger)fullUploadLength;
-(BOOL)chunkFetcher:(GTMHTTPFetcher *)chunkFetcher
willRetry:(BOOL)willRetry
forError:(NSError *)error;
- (void)chunkFetcher:(GTMHTTPFetcher *)chunkFetcher
finishedWithData:(NSData *)data
error:(NSError *)error;
@end
@interface GTMHTTPUploadFetcher (PrivateMethods)
// private methods of the superclass
- (void)invokeSentDataCallback:(SEL)sel
target:(id)target
didSendBodyData:(NSInteger)bytesWritten
totalBytesWritten:(NSInteger)totalBytesWritten
totalBytesExpectedToWrite:(NSInteger)totalBytesExpectedToWrite;
- (void)invokeFetchCallback:(SEL)sel
target:(id)target
data:(NSData *)data
error:(NSError *)error;
- (BOOL)invokeRetryCallback:(SEL)sel
target:(id)target
willRetry:(BOOL)willRetry
error:(NSError *)error;
@end
@implementation GTMHTTPUploadFetcher
+ (GTMHTTPUploadFetcher *)uploadFetcherWithRequest:(NSURLRequest *)request
uploadData:(NSData *)data
uploadMIMEType:(NSString *)uploadMIMEType
chunkSize:(NSUInteger)chunkSize
fetcherService:(GTMHTTPFetcherService *)fetcherService {
GTMHTTPUploadFetcher *fetcher = [self uploadFetcherWithRequest:request
fetcherService:fetcherService];
[fetcher setLocationURL:nil
uploadData:data
uploadFileHandle:nil
uploadMIMEType:uploadMIMEType
chunkSize:chunkSize];
return fetcher;
}
+ (GTMHTTPUploadFetcher *)uploadFetcherWithRequest:(NSURLRequest *)request
uploadFileHandle:(NSFileHandle *)fileHandle
uploadMIMEType:(NSString *)uploadMIMEType
chunkSize:(NSUInteger)chunkSize
fetcherService:(GTMHTTPFetcherService *)fetcherService {
GTMHTTPUploadFetcher *fetcher = [self uploadFetcherWithRequest:request
fetcherService:fetcherService];
[fetcher setLocationURL:nil
uploadData:nil
uploadFileHandle:fileHandle
uploadMIMEType:uploadMIMEType
chunkSize:chunkSize];
return fetcher;
}
+ (GTMHTTPUploadFetcher *)uploadFetcherWithLocation:(NSURL *)locationURL
uploadFileHandle:(NSFileHandle *)fileHandle
uploadMIMEType:(NSString *)uploadMIMEType
chunkSize:(NSUInteger)chunkSize
fetcherService:(GTMHTTPFetcherService *)fetcherService {
GTMHTTPUploadFetcher *fetcher = [self uploadFetcherWithRequest:nil
fetcherService:fetcherService];
[fetcher setLocationURL:locationURL
uploadData:nil
uploadFileHandle:fileHandle
uploadMIMEType:uploadMIMEType
chunkSize:chunkSize];
return fetcher;
}
+ (GTMHTTPUploadFetcher *)uploadFetcherWithRequest:(NSURLRequest *)request
fetcherService:(GTMHTTPFetcherService *)fetcherService {
// Internal utility method for instantiating fetchers
GTMHTTPUploadFetcher *fetcher;
if (fetcherService) {
fetcher = [fetcherService fetcherWithRequest:request
fetcherClass:self];
} else {
fetcher = (GTMHTTPUploadFetcher *) [self fetcherWithRequest:request];
}
return fetcher;
}
- (void)setLocationURL:(NSURL *)location
uploadData:(NSData *)data
uploadFileHandle:(NSFileHandle *)fileHandle
uploadMIMEType:(NSString *)uploadMIMEType
chunkSize:(NSUInteger)chunkSize {
#if DEBUG
NSAssert((data == nil) != (fileHandle == nil),
@"upload data and fileHandle are mutually exclusive");
NSAssert((self.mutableRequest == nil) != (location == nil),
@"request and location are mutually exclusive");
NSAssert(chunkSize > 0,@"chunk size is zero");
NSAssert(chunkSize != NSUIntegerMax, @"chunk size is sentinel value");
#endif
[self setLocationURL:location];
[self setUploadData:data];
[self setUploadFileHandle:fileHandle];
[self setUploadMIMEType:uploadMIMEType];
[self setChunkSize:chunkSize];
// indicate that we've not yet determined the file handle's length
uploadFileHandleLength_ = -1;
// indicate that we've not yet determined the upload fetcher status
statusCode_ = -1;
// if this is restarting an upload begun by another fetcher,
// the location is specified but the request is nil
isRestartedUpload_ = (location != nil);
// add our custom headers to the initial request indicating the data
// type and total size to be delivered later in the chunk requests
NSMutableURLRequest *mutableReq = [self mutableRequest];
NSNumber *lengthNum = [NSNumber numberWithUnsignedInteger:[self fullUploadLength]];
[mutableReq setValue:[lengthNum stringValue]
forHTTPHeaderField:@"X-Upload-Content-Length"];
[mutableReq setValue:uploadMIMEType
forHTTPHeaderField:@"X-Upload-Content-Type"];
}
- (void)dealloc {
[self releaseCallbacks];
[chunkFetcher_ release];
[locationURL_ release];
[locationChangeBlock_ release];
[uploadData_ release];
[uploadFileHandle_ release];
[uploadMIMEType_ release];
[responseHeaders_ release];
[super dealloc];
}
#pragma mark -
- (NSUInteger)fullUploadLength {
if (uploadData_) {
return [uploadData_ length];
} else {
if (uploadFileHandleLength_ == -1) {
// first time through, seek to end to determine file length
uploadFileHandleLength_ = (NSInteger) [uploadFileHandle_ seekToEndOfFile];
}
return (NSUInteger)uploadFileHandleLength_;
}
}
- (NSData *)uploadSubdataWithOffset:(NSUInteger)offset
length:(NSUInteger)length {
NSData *resultData = nil;
if (uploadData_) {
NSRange range = NSMakeRange(offset, length);
resultData = [uploadData_ subdataWithRange:range];
} else {
@try {
[uploadFileHandle_ seekToFileOffset:offset];
resultData = [uploadFileHandle_ readDataOfLength:length];
}
@catch (NSException *exception) {
NSLog(@"uploadFileHandle exception: %@", exception);
}
}
return resultData;
}
#pragma mark Method overrides affecting the initial fetch only
- (BOOL)beginFetchWithDelegate:(id)delegate
didFinishSelector:(SEL)finishedSEL {
GTMAssertSelectorNilOrImplementedWithArgs(delegate, finishedSEL,
@encode(GTMHTTPFetcher *), @encode(NSData *), @encode(NSError *), 0);
// replace the finishedSEL with our own, since the initial finish callback
// is just the beginning of the upload experience
delegateFinishedSEL_ = finishedSEL;
// if the client is running early 10.5 or iPhone 2, we may need to manually
// send progress indication since NSURLConnection won't be calling back
// to us during uploads
needsManualProgress_ = ![GTMHTTPFetcher doesSupportSentDataCallback];
initialBodyLength_ = [[self bodyData] length];
if (isRestartedUpload_) {
if (![self isPaused]) {
if (delegate) {
[self setDelegate:delegate];
finishedSel_ = finishedSEL;
}
[self uploadNextChunkWithOffset:kQueryServerForOffset];
}
return YES;
}
// we don't need a finish selector since we're overriding
// -connectionDidFinishLoading
return [super beginFetchWithDelegate:delegate
didFinishSelector:NULL];
}
- (BOOL)beginFetchWithCompletionHandler:(void (^)(NSData *data, NSError *error))handler {
// we don't want to call into the delegate's completion block immediately
// after the finish of the initial connection (the delegate is called only
// when uploading finishes), so we substitute our own completion block to be
// called when the initial connection finishes
void (^holdBlock)(NSData *data, NSError *error) = [[handler copy] autorelease];
BOOL flag = [super beginFetchWithCompletionHandler:^(NSData *data, NSError *error) {
// callback
if (!isRestartedUpload_) {
if (error == nil) {
// swap in the actual completion block now, as it will be called later
// when the upload chunks have completed
[completionBlock_ autorelease];
completionBlock_ = [holdBlock copy];
} else {
// pass the error on to the actual completion block
holdBlock(nil, error);
}
} else {
// If there was no initial request, then this fetch is resuming some
// other uploadFetcher's initial request, and the superclass's connection
// is never used, so at this point we call the user's actual completion
// block.
holdBlock(data, error);
}
}];
return flag;
}
- (void)connection:(NSURLConnection *)connection
didSendBodyData:(NSInteger)bytesWritten
totalBytesWritten:(NSInteger)totalBytesWritten
totalBytesExpectedToWrite:(NSInteger)totalBytesExpectedToWrite {
// ignore this callback if we're doing manual progress, mainly so that
// we won't see duplicate progress callbacks when testing with
// doesSupportSentDataCallback turned off
if (needsManualProgress_) return;
[self uploadFetcher:self
didSendBytes:bytesWritten
totalBytesSent:totalBytesWritten
totalBytesExpectedToSend:totalBytesExpectedToWrite];
}
- (BOOL)shouldReleaseCallbacksUponCompletion {
// we don't want the superclass to release the delegate and callback
// blocks once the initial fetch has finished
//
// this is invoked for only successful completion of the connection;
// an error always will invoke and release the callbacks
return NO;
}
- (void)invokeFinalCallbacksWithData:(NSData *)data
error:(NSError *)error
shouldInvalidateLocation:(BOOL)shouldInvalidateLocation {
// avoid issues due to being released indirectly by a callback
[[self retain] autorelease];
if (shouldInvalidateLocation) {
[self setLocationURL:nil];
}
if (delegate_ && delegateFinishedSEL_) {
[self invokeFetchCallback:delegateFinishedSEL_
target:delegate_
data:data
error:error];
}
if (completionBlock_) {
completionBlock_(data, error);
}
[self setLocationChangeBlock:nil];
[self releaseCallbacks];
}
- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error {
// handle failure of the initial fetch as a simple fetcher failure, including
// calling the delegate, and allowing retry to happen if appropriate
SEL prevSel = finishedSel_; // should be null
finishedSel_ = delegateFinishedSEL_;
[super connection:connection didFailWithError:error];
// If retry later happens and succeeds, it shouldn't message the delegate
// since we'll continue to chunk uploads.
finishedSel_ = prevSel;
}
- (void)connectionDidFinishLoading:(NSURLConnection *)connection {
// we land here once the initial fetch sending the initial POST body
// has completed
// let the superclass end its connection
[super connectionDidFinishLoading:connection];
NSInteger statusCode = [super statusCode];
[self setStatusCode:statusCode];
NSData *downloadedData = [self downloadedData];
// we need to get the upload URL from the location header to continue
NSDictionary *responseHeaders = [self responseHeaders];
NSString *locationURLStr = [responseHeaders objectForKey:@"Location"];
NSError *error = nil;
if (statusCode >= 300) {
if (retryTimer_) return;
error = [NSError errorWithDomain:kGTMHTTPFetcherStatusDomain
code:statusCode
userInfo:nil];
} else if ([downloadedData length] > 0) {
// The initial response of the resumable upload protocol should have an
// empty body
//
// This problem typically happens because the upload create/edit link URL was
// not supplied with the request, and the server is thus expecting a non-
// resumable request/response. It may also happen if an error JSON error body
// is returned.
//
// We'll consider this status 501 Not Implemented rather than try to parse
// the body to determine the actual error, but will provide the data
// as userInfo for clients to inspect.
NSDictionary *userInfo = [NSDictionary dictionaryWithObject:downloadedData
forKey:kGTMHTTPFetcherStatusDataKey];
error = [NSError errorWithDomain:kGTMHTTPFetcherStatusDomain
code:501
userInfo:userInfo];
} else {
#if DEBUG
NSAssert([locationURLStr length] > 0, @"need upload location hdr");
#endif
if ([locationURLStr length] == 0) {
// we cannot continue since we do not know the location to use
// as our upload destination
//
// we'll consider this status 501 Not Implemented
error = [NSError errorWithDomain:kGTMHTTPFetcherStatusDomain
code:501
userInfo:nil];
}
}
if (error) {
[self invokeFinalCallbacksWithData:downloadedData
error:error
shouldInvalidateLocation:YES];
return;
}
[self setLocationURL:[NSURL URLWithString:locationURLStr]];
// we've now sent all of the initial post body data, so we need to include
// its size in future progress indicator callbacks
initialBodySent_ = initialBodyLength_;
if (needsManualProgress_) {
[self reportProgressManually];
}
// just in case the user paused us during the initial fetch...
if (![self isPaused]) {
[self uploadNextChunkWithOffset:0];
}
}
- (void)retryFetch {
// Override the fetcher's retryFetch to retry with the saved delegateFinishedSEL_.
[self stopFetchReleasingCallbacks:NO];
[self beginFetchWithDelegate:delegate_
didFinishSelector:delegateFinishedSEL_];
}
#pragma mark Chunk fetching methods
- (void)uploadNextChunkWithOffset:(NSUInteger)offset {
// use the properties in each chunk fetcher
NSMutableDictionary *props = [self properties];
[self uploadNextChunkWithOffset:offset
fetcherProperties:props];
}
- (void)uploadNextChunkWithOffset:(NSUInteger)offset
fetcherProperties:(NSMutableDictionary *)props {
// upload another chunk
NSUInteger chunkSize = [self chunkSize];
NSString *rangeStr, *lengthStr;
NSData *chunkData;
NSUInteger dataLen = [self fullUploadLength];
if (offset == kQueryServerForOffset) {
// resuming, so we'll initially send an empty data block and wait for the
// server to tell us where the current offset really is
chunkData = [NSData data];
rangeStr = [NSString stringWithFormat:@"bytes */%llu",
(unsigned long long)dataLen];
lengthStr = @"0";
offset = 0;
} else {
// uploading the next data chunk
if (dataLen == 0) {
#if DEBUG
NSAssert(offset == 0, @"offset %llu for empty data length", (unsigned long long)offset);
#endif
chunkData = [NSData data];
rangeStr = @"bytes */0";
lengthStr = @"0";
} else {
#if DEBUG
NSAssert(offset < dataLen , @"offset %llu exceeds data length %llu",
(unsigned long long)offset, (unsigned long long)dataLen);
#endif
NSUInteger thisChunkSize = chunkSize;
// if the chunk size is bigger than the remaining data, or else
// it's close enough in size to the remaining data that we'd rather
// avoid having a whole extra http fetch for the leftover bit, then make
// this chunk size exactly match the remaining data size
BOOL isChunkTooBig = (thisChunkSize + offset > dataLen);
BOOL isChunkAlmostBigEnough = (dataLen - offset < thisChunkSize + 2500);
if (isChunkTooBig || isChunkAlmostBigEnough) {
thisChunkSize = dataLen - offset;
}
chunkData = [self uploadSubdataWithOffset:offset
length:thisChunkSize];
rangeStr = [NSString stringWithFormat:@"bytes %llu-%llu/%llu",
(unsigned long long)offset,
(unsigned long long)(offset + thisChunkSize - 1),
(unsigned long long)dataLen];
lengthStr = [NSString stringWithFormat:@"%llu",
(unsigned long long)thisChunkSize];
}
}
// track the current offset for progress reporting
[self setCurrentOffset:offset];
//
// make the request for fetching
//
// the chunk upload URL requires no authentication header
NSURL *locURL = [self locationURL];
NSMutableURLRequest *chunkRequest = [NSMutableURLRequest requestWithURL:locURL];
[chunkRequest setHTTPMethod:@"PUT"];
// copy the user-agent from the original connection
NSURLRequest *origRequest = [self mutableRequest];
NSString *userAgent = [origRequest valueForHTTPHeaderField:@"User-Agent"];
if ([userAgent length] > 0) {
[chunkRequest setValue:userAgent forHTTPHeaderField:@"User-Agent"];
}
[chunkRequest setValue:rangeStr forHTTPHeaderField:@"Content-Range"];
[chunkRequest setValue:lengthStr forHTTPHeaderField:@"Content-Length"];
NSString *uploadMIMEType = [self uploadMIMEType];
[chunkRequest setValue:uploadMIMEType forHTTPHeaderField:@"Content-Type"];
//
// make a new fetcher
//
GTMHTTPFetcher *chunkFetcher;
chunkFetcher = [GTMHTTPFetcher fetcherWithRequest:chunkRequest];
[chunkFetcher setDelegateQueue:[self delegateQueue]];
[chunkFetcher setRunLoopModes:[self runLoopModes]];
[chunkFetcher setAllowedInsecureSchemes:[self allowedInsecureSchemes]];
[chunkFetcher setAllowLocalhostRequest:[self allowLocalhostRequest]];
// if the upload fetcher has a comment, use the same comment for chunks
NSString *baseComment = [self comment];
if (baseComment) {
[chunkFetcher setCommentWithFormat:@"%@ (%@)", baseComment, rangeStr];
}
// give the chunk fetcher the same properties as the previous chunk fetcher
[chunkFetcher setProperties:props];
// post the appropriate subset of the full data
[chunkFetcher setBodyData:chunkData];
// copy other fetcher settings to the new fetcher
[chunkFetcher setRetryEnabled:[self isRetryEnabled]];
[chunkFetcher setMaxRetryInterval:[self maxRetryInterval]];
[chunkFetcher setSentDataSelector:[self sentDataSelector]];
[chunkFetcher setCookieStorageMethod:[self cookieStorageMethod]];
if ([self isRetryEnabled]) {
// we interpose our own retry method both so the sender is the upload
// fetcher, and so we can change the request to ask the server to
// tell us where to resume the chunk
[chunkFetcher setRetrySelector:@selector(chunkFetcher:willRetry:forError:)];
}
[self setMutableRequest:chunkRequest];
// when fetching chunks, a 308 status means "upload more chunks", but
// success (200 or 201 status) and other failures are no different than
// for the regular object fetchers
BOOL didFetch = [chunkFetcher beginFetchWithDelegate:self
didFinishSelector:@selector(chunkFetcher:finishedWithData:error:)];
if (!didFetch) {
// something went horribly wrong, like the chunk upload URL is invalid
NSError *error = [NSError errorWithDomain:kGTMHTTPFetcherErrorDomain
code:kGTMHTTPFetcherErrorChunkUploadFailed
userInfo:nil];
[self invokeFinalCallbacksWithData:nil
error:error
shouldInvalidateLocation:YES];
[self destroyChunkFetcher];
} else {
// hang on to the fetcher in case we need to cancel it
[self setChunkFetcher:chunkFetcher];
}
}
- (void)reportProgressManually {
// reportProgressManually should be called only when there's no
// NSURLConnection support for sent data callbacks
// the user wants upload progress, and there's no support in NSURLConnection
// for it, so we'll provide it here after each chunk
//
// the progress will be based on the uploadData and currentOffset,
// so we can pass zeros
[self uploadFetcher:self
didSendBytes:0
totalBytesSent:0
totalBytesExpectedToSend:0];
}
- (void)chunkFetcher:(GTMHTTPFetcher *)chunkFetcher finishedWithData:(NSData *)data error:(NSError *)error {
[self setStatusCode:[chunkFetcher statusCode]];
[self setResponseHeaders:[chunkFetcher responseHeaders]];
if (error) {
int status = (int)[error code];
// status 308 is "resume incomplete", meaning we should get the offset
// from the Range header and upload the next chunk
//
// any other status really is an error
if (status == 308) {
[self handleResumeIncompleteStatusForChunkFetcher:chunkFetcher];
return;
} else {
// some unexpected status has occurred; handle it as we would a regular
// object fetcher failure
error = [NSError errorWithDomain:kGTMHTTPFetcherStatusDomain
code:status
userInfo:nil];
[self invokeFinalCallbacksWithData:data
error:error
shouldInvalidateLocation:NO];
[self destroyChunkFetcher];
return;
}
} else {
// the final chunk has uploaded successfully
#if DEBUG && !defined(NS_BLOCK_ASSERTIONS)
NSInteger status = [chunkFetcher statusCode];
NSAssert1(status == 200 || status == 201,
@"unexpected chunks status %d", (int)status);
#endif // DEBUG && !defined(NS_BLOCK_ASSERTIONS)
// take the chunk fetcher's data as our own
self.downloadedData = data;
if (needsManualProgress_) {
// do a final upload progress report, indicating all of the chunk data
// has been sent
NSUInteger fullDataLength = [self fullUploadLength] + initialBodyLength_;
[self setCurrentOffset:fullDataLength];
[self reportProgressManually];
}
// we're done
[self invokeFinalCallbacksWithData:data
error:error
shouldInvalidateLocation:YES];
[self destroyChunkFetcher];
}
}
- (void)handleResumeIncompleteStatusForChunkFetcher:(GTMHTTPFetcher *)chunkFetcher {
NSDictionary *responseHeaders = [chunkFetcher responseHeaders];
// parse the Range header from the server, since that tells us where we really
// want the next chunk to begin.
//
// lack of a range header means the server has no bytes stored for this upload
NSString *rangeStr = [responseHeaders objectForKey:@"Range"];
NSUInteger newOffset = 0;
if (rangeStr != nil) {
// parse a content-range, like "bytes=0-999", to find where our new
// offset for uploading from the data really is (at the end of the
// range)
NSScanner *scanner = [NSScanner scannerWithString:rangeStr];
long long rangeStart = 0, rangeEnd = 0;
if ([scanner scanString:@"bytes=" intoString:nil]
&& [scanner scanLongLong:&rangeStart]
&& [scanner scanString:@"-" intoString:nil]
&& [scanner scanLongLong:&rangeEnd]) {
newOffset = (NSUInteger)rangeEnd + 1;
}
}
[self setCurrentOffset:newOffset];
if (needsManualProgress_) {
[self reportProgressManually];
}
// if the response specifies a location, use that for future chunks
NSString *locationURLStr = [responseHeaders objectForKey:@"Location"];
if ([locationURLStr length] > 0) {
[self setLocationURL:[NSURL URLWithString:locationURLStr]];
}
// we want to destroy this chunk fetcher before creating the next one, but
// we want to pass on its properties
NSMutableDictionary *props = [[[chunkFetcher properties] retain] autorelease];
// we no longer need to be able to cancel this chunkFetcher
[self destroyChunkFetcher];
[self uploadNextChunkWithOffset:newOffset
fetcherProperties:props];
}
-(BOOL)chunkFetcher:(GTMHTTPFetcher *)chunkFetcher willRetry:(BOOL)willRetry forError:(NSError *)error {
if ([error code] == 308
&& [[error domain] isEqual:kGTMHTTPFetcherStatusDomain]) {
// 308 is a normal chunk fethcher response, not an error
// that needs to be retried
return NO;
}
if (delegate_ && retrySel_) {
// call the client with the upload fetcher as the sender (not the chunk
// fetcher) to find out if it wants to retry
willRetry = [self invokeRetryCallback:retrySel_
target:delegate_
willRetry:willRetry
error:error];
}
if (retryBlock_) {
willRetry = retryBlock_(willRetry, error);
}
if (willRetry) {
// change the request being retried into a query to the server to
// tell us where to resume
NSMutableURLRequest *chunkRequest = [chunkFetcher mutableRequest];
NSUInteger dataLen = [self fullUploadLength];
NSString *rangeStr = [NSString stringWithFormat:@"bytes */%llu",
(unsigned long long)dataLen];
[chunkRequest setValue:rangeStr forHTTPHeaderField:@"Content-Range"];
[chunkRequest setValue:@"0" forHTTPHeaderField:@"Content-Length"];
[chunkFetcher setBodyData:[NSData data]];
// we don't know what our actual offset is anymore, but the server
// will tell us
[self setCurrentOffset:0];
}
return willRetry;
}
- (void)destroyChunkFetcher {
[chunkFetcher_ stopFetching];
[chunkFetcher_ setProperties:nil];
[chunkFetcher_ autorelease];
chunkFetcher_ = nil;
}
// the chunk fetchers use this as their sentData method
- (void)uploadFetcher:(GTMHTTPFetcher *)chunkFetcher
didSendBytes:(NSInteger)bytesSent
totalBytesSent:(NSInteger)totalBytesSent
totalBytesExpectedToSend:(NSInteger)totalBytesExpected {
// the actual total bytes sent include the initial XML sent, plus the
// offset into the batched data prior to this fetcher
totalBytesSent += initialBodySent_ + currentOffset_;
// the total bytes expected include the initial XML and the full chunked
// data, independent of how big this fetcher's chunk is
totalBytesExpected = (NSInteger)(initialBodyLength_ + [self fullUploadLength]);
if (delegate_ && delegateSentDataSEL_) {
// ensure the chunk fetcher survives the callback in case the user pauses
// the upload process
[[chunkFetcher retain] autorelease];
[self invokeSentDataCallback:delegateSentDataSEL_
target:delegate_
didSendBodyData:bytesSent
totalBytesWritten:totalBytesSent
totalBytesExpectedToWrite:totalBytesExpected];
}
if (sentDataBlock_) {
sentDataBlock_(bytesSent, totalBytesSent, totalBytesExpected);
}
}
#pragma mark -
- (BOOL)isPaused {
return isPaused_;
}
- (void)pauseFetching {
isPaused_ = YES;
// pausing just means stopping the current chunk from uploading;
// when we resume, the magic offset value will force us to send
// a request to the server to figure out what bytes to start sending
//
// we won't try to cancel the initial data upload, but rather will look for
// the magic offset value in -connectionDidFinishLoading before
// creating first initial chunk fetcher, just in case the user
// paused during the initial data upload
[self destroyChunkFetcher];
}
- (void)resumeFetching {
if (isPaused_) {
isPaused_ = NO;
[self uploadNextChunkWithOffset:kQueryServerForOffset];
}
}
- (void)stopFetching {
// overrides the superclass
[self destroyChunkFetcher];
[super stopFetching];
}
#pragma mark -
@synthesize uploadData = uploadData_,
uploadFileHandle = uploadFileHandle_,
uploadMIMEType = uploadMIMEType_,
chunkSize = chunkSize_,
currentOffset = currentOffset_,
chunkFetcher = chunkFetcher_,
locationChangeBlock = locationChangeBlock_;
@dynamic activeFetcher;
@dynamic responseHeaders;
@dynamic statusCode;
- (NSDictionary *)responseHeaders {
// overrides the superclass
// if asked for the fetcher's response, use the most recent fetcher
if (responseHeaders_) {
return responseHeaders_;
} else {
// no chunk fetcher yet completed, so return whatever we have from the
// initial fetch
return [super responseHeaders];
}
}
- (void)setResponseHeaders:(NSDictionary *)dict {
[responseHeaders_ autorelease];
responseHeaders_ = [dict retain];
}
- (NSInteger)statusCode {
if (statusCode_ != -1) {
// overrides the superclass to indicate status appropriate to the initial
// or latest chunk fetch
return statusCode_;
} else {
return [super statusCode];
}
}
- (void)setStatusCode:(NSInteger)val {
statusCode_ = val;
}
- (SEL)sentDataSelector {
// overrides the superclass
if ((delegateSentDataSEL_ || sentDataBlock_) && !needsManualProgress_) {
return @selector(uploadFetcher:didSendBytes:totalBytesSent:totalBytesExpectedToSend:);
} else {
return NULL;
}
}
- (void)setSentDataSelector:(SEL)theSelector {
// overrides the superclass
delegateSentDataSEL_ = theSelector;
}
- (GTMHTTPFetcher *)activeFetcher {
if (chunkFetcher_) {
return chunkFetcher_;
} else {
return self;
}
}
- (NSURL *)locationURL {
return locationURL_;
}
- (void)setLocationURL:(NSURL *)url {
if (url != locationURL_) {
[locationURL_ release];
locationURL_ = [url retain];
if (locationChangeBlock_) {
locationChangeBlock_(url);
}
}
}
@end
#endif // #if !GDATA_REQUIRE_SERVICE_INCLUDES