Merge pull request #1514 from BrianBland/s3awsParameterParsing

[driver/s3aws] Update s3aws driver parameter parsing to match s3goamz
This commit is contained in:
Brian Bland 2016-03-07 16:13:26 -08:00
commit b61928652c

View file

@ -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 // 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 // with an IAM on an ec2 instance (in which case the instance credentials will
// be summoned when GetAuth is called) // be summoned when GetAuth is called)
accessKey, ok := parameters["accesskey"] accessKey := parameters["accesskey"]
if !ok { if accessKey == nil {
accessKey = "" accessKey = ""
} }
secretKey, ok := parameters["secretkey"] secretKey := parameters["secretkey"]
if !ok { if secretKey == nil {
secretKey = "" secretKey = ""
} }
regionName, ok := parameters["region"] regionName, ok := parameters["region"]
if !ok || fmt.Sprint(regionName) == "" { if regionName == nil || fmt.Sprint(regionName) == "" {
return nil, fmt.Errorf("No region parameter provided") return nil, fmt.Errorf("No region parameter provided")
} }
region := fmt.Sprint(regionName) region := fmt.Sprint(regionName)
@ -148,32 +148,47 @@ func FromParameters(parameters map[string]interface{}) (*Driver, error) {
return nil, fmt.Errorf("Invalid region provided: %v", region) 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") return nil, fmt.Errorf("No bucket parameter provided")
} }
encryptBool := false 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") 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 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") 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) 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)
@ -185,23 +200,24 @@ func FromParameters(parameters map[string]interface{}) (*Driver, error) {
chunkSize = v chunkSize = v
case int, uint, int32, uint32, uint64: case int, uint, int32, uint32, uint64:
chunkSize = reflect.ValueOf(v).Convert(reflect.TypeOf(chunkSize)).Int() chunkSize = reflect.ValueOf(v).Convert(reflect.TypeOf(chunkSize)).Int()
case nil:
// do nothing
default: default:
return nil, fmt.Errorf("invalid valud for chunksize: %#v", chunkSizeParam) return nil, fmt.Errorf("invalid value for chunksize: %#v", chunkSizeParam)
} }
if chunkSize < minChunkSize { 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) return nil, fmt.Errorf("The chunksize %#v parameter should be a number that is larger than or equal to %d", chunkSize, minChunkSize)
} }
}
rootDirectory, ok := parameters["rootdirectory"] rootDirectory := parameters["rootdirectory"]
if !ok { if rootDirectory == nil {
rootDirectory = "" rootDirectory = ""
} }
storageClass := s3.StorageClassStandard storageClass := s3.StorageClassStandard
storageClassParam, ok := parameters["storageclass"] storageClassParam := parameters["storageclass"]
if ok { if storageClassParam != nil {
storageClassString, ok := storageClassParam.(string) storageClassString, ok := storageClassParam.(string)
if !ok { if !ok {
return nil, fmt.Errorf("The storageclass parameter must be one of %v, %v invalid", []string{s3.StorageClassStandard, s3.StorageClassReducedRedundancy}, storageClassParam) 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 storageClass = storageClassString
} }
userAgent, ok := parameters["useragent"] userAgent := parameters["useragent"]
if !ok { if userAgent == nil {
userAgent = "" userAgent = ""
} }