Improves flexibility of configuration handling for S3 driver

Treats nil parameters the same as unprovided parameters (fixes issues
where certain parameters are printed to "<nil>").
Accepts "true" and "false" string values for boolean parameters.

Signed-off-by: Brian Bland <brian.bland@docker.com>

docs/storage/driver/s3/s3.go

@@ -107,17 +107,18 @@ 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"]
+	accessKey := parameters["accesskey"]
-	if !ok {
+	if accessKey == nil {
 		accessKey = ""
 	}
-	secretKey, ok := parameters["secretkey"]
+
-	if !ok {
+	secretKey := parameters["secretkey"]
+	if secretKey == nil {
 		secretKey = ""
 	}
 
-	regionName, ok := parameters["region"]
+	regionName := parameters["region"]
-	if !ok || fmt.Sprint(regionName) == "" {
+	if regionName == nil || fmt.Sprint(regionName) == "" {
 		return nil, fmt.Errorf("No region parameter provided")
 	}
 	region := aws.GetRegion(fmt.Sprint(regionName))
@@ -125,69 +126,93 @@ func FromParameters(parameters map[string]interface{}) (*Driver, error) {
 		return nil, fmt.Errorf("Invalid region provided: %v", region)
 	}
 
-	bucket, ok := parameters["bucket"]
+	bucket := parameters["bucket"]
-	if !ok || fmt.Sprint(bucket) == "" {
+	if bucket == nil || fmt.Sprint(bucket) == "" {
 		return nil, fmt.Errorf("No bucket parameter provided")
 	}
 
 	encryptBool := false
-	encrypt, ok := parameters["encrypt"]
+	encrypt := parameters["encrypt"]
-	if ok {
+	switch encrypt := encrypt.(type) {
-		encryptBool, ok = encrypt.(bool)
+	case string:
-		if !ok {
+		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"]
+	secure := parameters["secure"]
-	if ok {
+	switch secure := secure.(type) {
-		secureBool, ok = secure.(bool)
+	case string:
-		if !ok {
+		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")
 	}
 
 	v4AuthBool := false
-	v4Auth, ok := parameters["v4auth"]
+	v4Auth := parameters["v4auth"]
-	if ok {
+	switch v4Auth := v4Auth.(type) {
-		v4AuthBool, ok = v4Auth.(bool)
+	case string:
-		if !ok {
+		b, err := strconv.ParseBool(v4Auth)
+		if err != nil {
 			return nil, fmt.Errorf("The v4auth parameter should be a boolean")
 		}
+		v4AuthBool = b
+	case bool:
+		v4AuthBool = v4Auth
+	case nil:
+		// do nothing
+	default:
+		return nil, fmt.Errorf("The v4auth parameter should be a boolean")
 	}
 
 	chunkSize := int64(defaultChunkSize)
-	chunkSizeParam, ok := parameters["chunksize"]
+	chunkSizeParam := parameters["chunksize"]
-	if ok {
+	switch v := chunkSizeParam.(type) {
-		switch v := chunkSizeParam.(type) {
+	case string:
-		case string:
+		vv, err := strconv.ParseInt(v, 0, 64)
-			vv, err := strconv.ParseInt(v, 0, 64)
+		if err != nil {
-			if err != nil {
+			return nil, fmt.Errorf("chunksize parameter must be an integer, %v invalid", chunkSizeParam)
-				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 value 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)
 		}
+		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 chunkSize < minChunkSize {
-	if !ok {
+		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.StandardStorage
-	storageClassParam, ok := parameters["storageclass"]
+	storageClassParam := parameters["storageclass"]
-	if ok {
+	if storageClassParam != nil {
 		storageClassString, ok := storageClassParam.(string)
 		if !ok {
 			return nil, fmt.Errorf("The storageclass parameter must be one of %v, %v invalid", []s3.StorageClass{s3.StandardStorage, s3.ReducedRedundancy}, storageClassParam)
@@ -200,8 +225,8 @@ func FromParameters(parameters map[string]interface{}) (*Driver, error) {
 		storageClass = storageClassCasted
 	}
 
-	userAgent, ok := parameters["useragent"]
+	userAgent := parameters["useragent"]
-	if !ok {
+	if userAgent == nil {
 		userAgent = ""
 	}