From 2494c28e1f590caacfaeb203c8b17deed2dd31d1 Mon Sep 17 00:00:00 2001
From: Brian Bland <brian.bland@docker.com>
Date: Mon, 7 Mar 2016 11:50:46 -0800
Subject: [PATCH] [driver/s3aws] Update s3aws driver parameter parsing to match
 s3goamz

Mirrors changes from #1414 into the newer driver

Signed-off-by: Brian Bland <brian.bland@docker.com>
---
 docs/storage/driver/s3-aws/s3.go | 96 +++++++++++++++++++-------------
 1 file changed, 56 insertions(+), 40 deletions(-)

diff --git a/docs/storage/driver/s3-aws/s3.go b/docs/storage/driver/s3-aws/s3.go
index af62d3f07..0e113680f 100644
--- a/docs/storage/driver/s3-aws/s3.go
+++ b/docs/storage/driver/s3-aws/s3.go
@@ -129,17 +129,17 @@ func FromParameters(parameters map[string]interface{}) (*Driver, error) {
 	// Providing no values for these is valid in case the user is authenticating
 	// with an IAM on an ec2 instance (in which case the instance credentials will
 	// be summoned when GetAuth is called)
-	accessKey, ok := parameters["accesskey"]
-	if !ok {
+	accessKey := parameters["accesskey"]
+	if accessKey == nil {
 		accessKey = ""
 	}
-	secretKey, ok := parameters["secretkey"]
-	if !ok {
+	secretKey := parameters["secretkey"]
+	if secretKey == nil {
 		secretKey = ""
 	}
 
 	regionName, ok := parameters["region"]
-	if !ok || fmt.Sprint(regionName) == "" {
+	if regionName == nil || fmt.Sprint(regionName) == "" {
 		return nil, fmt.Errorf("No region parameter provided")
 	}
 	region := fmt.Sprint(regionName)
@@ -148,60 +148,76 @@ func FromParameters(parameters map[string]interface{}) (*Driver, error) {
 		return nil, fmt.Errorf("Invalid region provided: %v", region)
 	}
 
-	bucket, ok := parameters["bucket"]
-	if !ok || fmt.Sprint(bucket) == "" {
+	bucket := parameters["bucket"]
+	if bucket == nil || fmt.Sprint(bucket) == "" {
 		return nil, fmt.Errorf("No bucket parameter provided")
 	}
 
 	encryptBool := false
-	encrypt, ok := parameters["encrypt"]
-	if ok {
-		encryptBool, ok = encrypt.(bool)
-		if !ok {
+	encrypt := parameters["encrypt"]
+	switch encrypt := encrypt.(type) {
+	case string:
+		b, err := strconv.ParseBool(encrypt)
+		if err != nil {
 			return nil, fmt.Errorf("The encrypt parameter should be a boolean")
 		}
+		encryptBool = b
+	case bool:
+		encryptBool = encrypt
+	case nil:
+		// do nothing
+	default:
+		return nil, fmt.Errorf("The encrypt parameter should be a boolean")
 	}
 
 	secureBool := true
-	secure, ok := parameters["secure"]
-	if ok {
-		secureBool, ok = secure.(bool)
-		if !ok {
+	secure := parameters["secure"]
+	switch secure := secure.(type) {
+	case string:
+		b, err := strconv.ParseBool(secure)
+		if err != nil {
 			return nil, fmt.Errorf("The secure parameter should be a boolean")
 		}
+		secureBool = b
+	case bool:
+		secureBool = secure
+	case nil:
+		// do nothing
+	default:
+		return nil, fmt.Errorf("The secure parameter should be a boolean")
 	}
 
 	chunkSize := int64(defaultChunkSize)
-	chunkSizeParam, ok := parameters["chunksize"]
-	if ok {
-		switch v := chunkSizeParam.(type) {
-		case string:
-			vv, err := strconv.ParseInt(v, 0, 64)
-			if err != nil {
-				return nil, fmt.Errorf("chunksize parameter must be an integer, %v invalid", chunkSizeParam)
-			}
-			chunkSize = vv
-		case int64:
-			chunkSize = v
-		case int, uint, int32, uint32, uint64:
-			chunkSize = reflect.ValueOf(v).Convert(reflect.TypeOf(chunkSize)).Int()
-		default:
-			return nil, fmt.Errorf("invalid valud for chunksize: %#v", chunkSizeParam)
-		}
-
-		if chunkSize < minChunkSize {
-			return nil, fmt.Errorf("The chunksize %#v parameter should be a number that is larger than or equal to %d", chunkSize, minChunkSize)
+	chunkSizeParam := parameters["chunksize"]
+	switch v := chunkSizeParam.(type) {
+	case string:
+		vv, err := strconv.ParseInt(v, 0, 64)
+		if err != nil {
+			return nil, fmt.Errorf("chunksize parameter must be an integer, %v invalid", chunkSizeParam)
 		}
+		chunkSize = vv
+	case int64:
+		chunkSize = v
+	case int, uint, int32, uint32, uint64:
+		chunkSize = reflect.ValueOf(v).Convert(reflect.TypeOf(chunkSize)).Int()
+	case nil:
+		// do nothing
+	default:
+		return nil, fmt.Errorf("invalid value for chunksize: %#v", chunkSizeParam)
 	}
 
-	rootDirectory, ok := parameters["rootdirectory"]
-	if !ok {
+	if chunkSize < minChunkSize {
+		return nil, fmt.Errorf("The chunksize %#v parameter should be a number that is larger than or equal to %d", chunkSize, minChunkSize)
+	}
+
+	rootDirectory := parameters["rootdirectory"]
+	if rootDirectory == nil {
 		rootDirectory = ""
 	}
 
 	storageClass := s3.StorageClassStandard
-	storageClassParam, ok := parameters["storageclass"]
-	if ok {
+	storageClassParam := parameters["storageclass"]
+	if storageClassParam != nil {
 		storageClassString, ok := storageClassParam.(string)
 		if !ok {
 			return nil, fmt.Errorf("The storageclass parameter must be one of %v, %v invalid", []string{s3.StorageClassStandard, s3.StorageClassReducedRedundancy}, storageClassParam)
@@ -214,8 +230,8 @@ func FromParameters(parameters map[string]interface{}) (*Driver, error) {
 		storageClass = storageClassString
 	}
 
-	userAgent, ok := parameters["useragent"]
-	if !ok {
+	userAgent := parameters["useragent"]
+	if userAgent == nil {
 		userAgent = ""
 	}