Merge pull request #152 from mjbenedict/gzipHTTPRequests

Gzip http requests

Author: Pearapps

Classes/Networking/RequestBody/TMFormEncodedRequestBody.m

@@ -38,6 +38,10 @@ - (nullable NSString *)contentType {
     return @"application/x-www-form-urlencoded; charset=utf-8";
 }
 
+- (nullable NSString *)contentEncoding {
+    return nil;
+}
+
 - (nonnull NSDictionary *)parameters {
     return self.body;
 }

Classes/Networking/RequestBody/TMGZIPEncodedRequestBody.h

@@ -0,0 +1,26 @@
+//
+//  TMGZIPEncodeRequestBody.h
+//  TMTumblrSDK
+//
+//  Created by Michael Benedict on 2/9/18.
+//
+
+#import <Foundation/Foundation.h>
+#import "TMRequestBody.h"
+
+/**
+ * A request body that represents gzipped data.
+ */
+__attribute__((objc_subclassing_restricted))
+@interface TMGZIPEncodedRequestBody : NSObject <TMRequestBody>
+
+/**
+ *  Initialized instance of @c TMGZIPEncodedRequestBody.
+ *
+ *  @param body The uncompressed body that will be transformed into a gzipped request body.
+ *
+ *  @return A newly initialized instance of @c TMGZIPEncodedRequestBody.
+ */
+- (nonnull instancetype)initWithRequestBody:(nonnull id<TMRequestBody>)body;
+
+@end

Classes/Networking/RequestBody/TMGZIPEncodedRequestBody.m

@@ -0,0 +1,120 @@
+//
+//  TMGZIPEncodedRequestBody.m
+//  TMTumblrSDK
+//
+//  Created by Michael Benedict on 2/9/18.
+//
+
+#import "TMRequestBody.h"
+#import "TMGZIPEncodedRequestBody.h"
+#include <zlib.h>
+#define CHUNKSIZE (1024*4)
+
+@interface TMGZIPEncodedRequestBody ()
+
+@property (nonatomic, nonnull, readonly) id<TMRequestBody> originalBody;
+@property (nonatomic, nonnull, readonly) NSData *compressedBodyData;
+
+@end
+
+@implementation TMGZIPEncodedRequestBody
+
+- (nonnull instancetype)initWithRequestBody:(nonnull id<TMRequestBody>)body {
+    NSParameterAssert(body);
+    self = [super init];
+    
+    if (self) {
+        _originalBody = body;
+        _compressedBodyData = [self compressedBody:[body bodyData]];
+    }
+    
+    return self;
+}
+
+#pragma mark - TMRequestBody
+
+- (nullable NSString *)contentType {
+    return [_originalBody contentType];
+}
+
+- (nullable NSString *)contentEncoding {
+    if (!_compressedBodyData ) {
+        return nil;
+    }
+    else {
+        return @"gzip";
+    }
+}
+
+
+- (nullable NSData *)bodyData {
+    if (!_compressedBodyData) {
+        return [_originalBody bodyData];
+    }
+    else {
+        return _compressedBodyData;
+    }
+}
+
+- (nonnull NSDictionary *)parameters {
+    return [_originalBody parameters];
+}
+
+- (BOOL)encodeParameters {
+    return [_originalBody encodeParameters];
+}
+
+- (NSData *)compressedBody:(NSData *)data {
+    z_stream strm;
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    strm.total_out = 0;
+    strm.next_in=(Bytef *)[data bytes];
+    strm.avail_in = (unsigned int)[data length];
+    
+    /* windowBits (15+16) - Base two logarithm of the maximum window size (the size of the history buffer). It should be in the range 8..15.
+     Add 16 to windowBits to write a simple gzip header and trailer around the compressed data instead of a zlib wrapper. The gzip header
+     will have no file name, no extra data, no comment, no modification time (set to zero), no header crc, and the
+     operating system will be set to 255 (unknown).
+     
+     15+16 - will give gzip compatible output
+     
+     memLevel  - The memLevel parameter specifies how much memory should be allocated for the internal compression state.
+     memLevel=1 uses minimum memory but is slow and reduces compression ratio; memLevel=9 uses maximum memory for
+     optimal speed.  The default value is 8.  See zconf.h for total memory usage as a function of windowBits and memLevel.
+     */
+    
+    if (deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, (15+16), 8, Z_DEFAULT_STRATEGY) == Z_OK) {
+        
+        // 16K chunks for expansion
+        NSMutableData *compressed = [[NSMutableData alloc] initWithLength:CHUNKSIZE];
+        
+        do {
+            if (strm.total_out >= [compressed length]) {
+                [compressed increaseLengthBy:CHUNKSIZE];
+            }
+            
+            strm.next_out = [compressed mutableBytes] + strm.total_out;
+            strm.avail_out = (unsigned int)([compressed length] - strm.total_out);
+            
+            if (Z_STREAM_ERROR == deflate(&strm, Z_FINISH)) {
+                return nil;
+            }
+            
+        } while (strm.avail_out == 0);
+        
+        if (deflateEnd(&strm) != Z_OK) {
+            return nil;
+        }
+        
+        [compressed setLength: strm.total_out];
+        
+        return compressed;
+    }
+    else {
+        return nil;
+    }
+}
+
+@end

Classes/Networking/RequestBody/TMJSONEncodedRequestBody.m

@@ -33,6 +33,11 @@ - (nullable NSString *)contentType {
     return @"application/json";
 }
 
+- (nullable NSString *)contentEncoding {
+    return nil;
+}
+
+
 - (nullable NSData *)bodyData {
     return [NSJSONSerialization dataWithJSONObject:self.JSONDictionary options:0 error:nil];
 }

Classes/Networking/RequestBody/TMMultipartRequestBody.m

@@ -60,6 +60,10 @@ - (nullable NSString *)contentType {
     return [[NSString alloc] initWithFormat:@"multipart/form-data; charset=utf-8; boundary=%@", TMMultipartBoundary];
 }
 
+- (nullable NSString *)contentEncoding {
+    return nil;
+}
+
 - (nullable NSData *)bodyData {
 
     NSMutableArray *parts = [[NSMutableArray alloc] init];

Classes/Networking/RequestBody/TMQueryEncodedRequestBody.m

@@ -38,6 +38,10 @@ - (nullable NSString *)contentType {
     return nil;
 }
 
+- (nullable NSString *)contentEncoding {
+    return nil;
+}
+
 - (nonnull NSDictionary *)parameters {
     return self.queryDictionary;
 }

Classes/Networking/RequestBody/TMRequestBody.h

@@ -25,6 +25,13 @@
  */
 - (nullable NSString *)contentType;
 
+/**
+ *  Gets the content encoding for the header of Content-Encoding on a request.
+ *
+ *  @return The content encoding of the request body.
+ */
+- (nullable NSString *)contentEncoding;
+
 /**
  *  The parameters represented by the body data.
  *

Classes/TMRequestHelpers/TMRequestParamaterizer.m

@@ -79,6 +79,13 @@ - (nonnull NSURLRequest *)URLRequestWithRequest:(nonnull id <TMRequest>)request
         if (contentType) {
             [URLRequest addValue:contentType forHTTPHeaderField:@"Content-Type"];
         }
+        
+        NSString *contentEncoding = [requestBody contentEncoding];
+        
+        if (contentEncoding) {
+            [URLRequest addValue:contentEncoding forHTTPHeaderField:@"Content-Encoding"];
+        }
+
 
         URLRequest.HTTPMethod = [TMRequestMethodHelpers stringFromMethod:request.method];
 

ExampleiOS/ExampleiOSTests/TMRequestBodiesTests.m

@@ -10,6 +10,8 @@
 #import <TMTumblrSDK/TMQueryEncodedRequestBody.h>
 #import <TMTumblrSDK/TMFormEncodedRequestBody.h>
 #import <TMTumblrSDK/TMJSONEncodedRequestBody.h>
+#import <TMTumblrSDK/TMGZIPEncodedRequestBody.h>
+#import <zlib.h>
 
 @interface TMRequestBodiesTests : XCTestCase
 
@@ -43,6 +45,13 @@ - (void)testQueryContentTypeIsRightForJSON {
     XCTAssert([body.contentType isEqualToString:@"application/json"]);
 }
 
+- (void)testQueryContentTypeIsRightForGzippedJSON {
+    TMJSONEncodedRequestBody *jsonBody = [[TMJSONEncodedRequestBody alloc] initWithJSONDictionary:@{@"4" : @3}];
+    TMGZIPEncodedRequestBody *body = [[TMGZIPEncodedRequestBody alloc] initWithRequestBody:jsonBody];
+
+    XCTAssert([body.contentType isEqualToString:@"application/json"]);
+}
+
 - (void)testContentTypeIsNil {
     NSString *contentType = [[[TMQueryEncodedRequestBody alloc] initWithQueryDictionary:@{@"paul" : @"kenny", @"pool" : @"object"}] contentType];
     XCTAssertNil(contentType);
@@ -64,4 +73,48 @@ - (void)testJSONEncodedRequestBodysParamtersAreCorrect {
     XCTAssert([[body parameters] isEqual:@{@"4" : @3}]);
 }
 
+- (void)testBodyIsRightForGzippedJSON {
+    TMJSONEncodedRequestBody *jsonBody = [[TMJSONEncodedRequestBody alloc] initWithJSONDictionary:@{@"4" : @3}];
+    TMGZIPEncodedRequestBody *body = [[TMGZIPEncodedRequestBody alloc] initWithRequestBody:jsonBody];
+
+    XCTAssert([[self unZipTinyData:body.bodyData] isEqualToString:@"{\"4\":3}"],  @"Strings are not equal %@ %@", @"{\"4\":3}", [self unZipTinyData:body.bodyData]);
+}
+
+- (void)testFormEncodedGzippedRequestBodysParamtersAreCorrect {
+    TMFormEncodedRequestBody *formBody = [[TMFormEncodedRequestBody alloc] initWithBody:@{@"4" : @3}];
+    TMGZIPEncodedRequestBody *body = [[TMGZIPEncodedRequestBody alloc] initWithRequestBody:formBody];
+
+    XCTAssert([[body parameters] isEqual:@{@"4" : @3}]);
+}
+
+#pragma mark - Helpers
+// tiny unzip functionality that can return up to 1k of unzipped data which is good enough for unit tests
+- (NSString *)unZipTinyData:(NSData *)data {
+    z_stream strm;
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    strm.avail_in = (unsigned int)[data length];
+    strm.next_in = (Bytef *)[data bytes];
+    NSMutableData *uncompressed = [[NSMutableData alloc] initWithLength:1024];
+    strm.avail_out = 1024;
+    strm.next_out = [uncompressed mutableBytes];
+
+    // https://stackoverflow.com/a/22311297/8838812 shows MAX_WBITS | 16 is
+    // needed for decoding the gzip format
+    if (inflateInit2(&strm, MAX_WBITS | 16) != Z_OK) {
+        return nil;
+    }
+
+    int z_error = inflate(&strm, Z_NO_FLUSH);
+
+    if (z_error == Z_STREAM_END) {
+        [uncompressed setLength:strm.total_out];
+        return [[NSString alloc] initWithData:uncompressed encoding:NSUTF8StringEncoding];
+    }
+    else {
+        return nil;
+    }
+}
+
 @end

ExampleiOS/ExampleiOSTests/TMRequestBodyTests.swift

@@ -31,6 +31,37 @@ final class TMRequestBodyTests: XCTestCase {
         XCTAssertTrue(requestBody.encodeParameters(), "Query encoded request body should encode parameters.")
     }
 
+    func testJSONRequestContentType() {
+        let dictionary = testDictionary()
+        let requestBody = TMJSONEncodedRequestBody(jsonDictionary: dictionary)
+        XCTAssertEqual(requestBody.contentType() as String?, "application/json", "JSON request should have Content-Type: application/json.")
+    }
+
+    func testJSONRequestContentEncoding() {
+        let dictionary = testDictionary()
+        let requestBody = TMJSONEncodedRequestBody(jsonDictionary: dictionary)
+        XCTAssertEqual(requestBody.contentEncoding() as String?, nil, "JSON request should NOT have a Content-Encoding.")
+    }
+
+    func testGZIPJSONRequestContentType() {
+        let dictionary = testDictionary()
+        let requestBody = TMGZIPEncodedRequestBody(requestBody: TMJSONEncodedRequestBody(jsonDictionary: dictionary))
+        XCTAssertEqual(requestBody.contentType() as String?, "application/json", "GZipped JSON request should have Content-Type: application/json.")
+    }
+
+    func testGZIPJSONRequestContentEncoding() {
+        let dictionary = testDictionary()
+        let requestBody = TMGZIPEncodedRequestBody(requestBody: TMJSONEncodedRequestBody(jsonDictionary: dictionary))
+        XCTAssertEqual(requestBody.contentEncoding() as String?, "gzip", "GZipped JSON request should have Content-Encoding: gzip.")
+    }
+
+    func testGZIPFormEncodedBody() {
+        let dictionary = testDictionary()
+        let requestBody = TMGZIPEncodedRequestBody(requestBody: TMFormEncodedRequestBody(body: dictionary))
+        XCTAssertEqual(requestBody.parameters() as NSDictionary, dictionary as NSDictionary, "Form encoded request parameters should equal the body dictionary passed in.")
+        XCTAssertTrue(requestBody.encodeParameters(), "Form encoded request body should encode parameters.")
+    }
+
     // MARK: Private
 
     private func testDictionary() -> [AnyHashable: Any] {