Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 build.go // Package rest provides RESTful serialization of AWS requests and responses. package rest import ( "bytes" "encoding/base64" "fmt" "io" "math" "net/http" "net/url" "path" "reflect" "strconv" "strings" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/private/protocol" ) const ( floatNaN = "NaN" floatInf = "Infinity" floatNegInf = "-Infinity" ) // Whether the byte value can be sent without escaping in AWS URLs var noEscape [256]bool var errValueNotSet = fmt.Errorf("value not set") var byteSliceType = reflect.TypeOf([]byte{}) func init() { for i := 0; i < len(noEscape); i++ { // AWS expects every character except these to be escaped noEscape[i] = (i >= 'A' && i <= 'Z') \|\| (i >= 'a' && i <= 'z') \|\| (i >= '0' && i <= '9') \|\| i == '-' \|\| i == '.' \|\| i == '_' \|\| i == '~' } } // BuildHandler is a named request handler for building rest protocol requests var BuildHandler = request.NamedHandler{Name: "awssdk.rest.Build", Fn: Build} // Build builds the REST component of a service request. func Build(r request.Request) { if r.ParamsFilled() { v := reflect.ValueOf(r.Params).Elem() buildLocationElements(r, v, false) buildBody(r, v) } } // BuildAsGET builds the REST component of a service request with the ability to hoist // data from the body. func BuildAsGET(r request.Request) { if r.ParamsFilled() { v := reflect.ValueOf(r.Params).Elem() buildLocationElements(r, v, true) buildBody(r, v) } } func buildLocationElements(r request.Request, v reflect.Value, buildGETQuery bool) { query := r.HTTPRequest.URL.Query() // Setup the raw path to match the base path pattern. This is needed // so that when the path is mutated a custom escaped version can be // stored in RawPath that will be used by the Go client. r.HTTPRequest.URL.RawPath = r.HTTPRequest.URL.Path for i := 0; i < v.NumField(); i++ { m := v.Field(i) if n := v.Type().Field(i).Name; n[0:1] == strings.ToLower(n[0:1]) { continue } if m.IsValid() { field := v.Type().Field(i) name := field.Tag.Get("locationName") if name == "" { name = field.Name } if kind := m.Kind(); kind == reflect.Ptr { m = m.Elem() } else if kind == reflect.Interface { if !m.Elem().IsValid() { continue } } if !m.IsValid() { continue } if field.Tag.Get("ignore") != "" { continue } // Support the ability to customize values to be marshaled as a // blob even though they were modeled as a string. Required for S3 // API operations like SSECustomerKey is modeled as string but // required to be base64 encoded in request. if field.Tag.Get("marshal-as") == "blob" { m = m.Convert(byteSliceType) } var err error switch field.Tag.Get("location") { case "headers": // header maps err = buildHeaderMap(&r.HTTPRequest.Header, m, field.Tag) case "header": err = buildHeader(&r.HTTPRequest.Header, m, name, field.Tag) case "uri": err = buildURI(r.HTTPRequest.URL, m, name, field.Tag) case "querystring": err = buildQueryString(query, m, name, field.Tag) default: if buildGETQuery { err = buildQueryString(query, m, name, field.Tag) } } r.Error = err } if r.Error != nil { return } } r.HTTPRequest.URL.RawQuery = query.Encode() if !aws.BoolValue(r.Config.DisableRestProtocolURICleaning) { cleanPath(r.HTTPRequest.URL) } } func buildBody(r request.Request, v reflect.Value) { if field, ok := v.Type().FieldByName("_"); ok { if payloadName := field.Tag.Get("payload"); payloadName != "" { pfield, _ := v.Type().FieldByName(payloadName) if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" { payload := reflect.Indirect(v.FieldByName(payloadName)) if payload.IsValid() && payload.Interface() != nil { switch reader := payload.Interface().(type) { case io.ReadSeeker: r.SetReaderBody(reader) case []byte: r.SetBufferBody(reader) case string: r.SetStringBody(reader) default: r.Error = awserr.New(request.ErrCodeSerialization, "failed to encode REST request", fmt.Errorf("unknown payload type %s", payload.Type())) } } } } } } func buildHeader(header http.Header, v reflect.Value, name string, tag reflect.StructTag) error { str, err := convertType(v, tag) if err == errValueNotSet { return nil } else if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to encode REST request", err) } name = strings.TrimSpace(name) str = strings.TrimSpace(str) header.Add(name, str) return nil } func buildHeaderMap(header http.Header, v reflect.Value, tag reflect.StructTag) error { prefix := tag.Get("locationName") for _, key := range v.MapKeys() { str, err := convertType(v.MapIndex(key), tag) if err == errValueNotSet { continue } else if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to encode REST request", err) } keyStr := strings.TrimSpace(key.String()) str = strings.TrimSpace(str) header.Add(prefix+keyStr, str) } return nil } func buildURI(u url.URL, v reflect.Value, name string, tag reflect.StructTag) error { value, err := convertType(v, tag) if err == errValueNotSet { return nil } else if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to encode REST request", err) } u.Path = strings.Replace(u.Path, "{"+name+"}", value, -1) u.Path = strings.Replace(u.Path, "{"+name+"+}", value, -1) u.RawPath = strings.Replace(u.RawPath, "{"+name+"}", EscapePath(value, true), -1) u.RawPath = strings.Replace(u.RawPath, "{"+name+"+}", EscapePath(value, false), -1) return nil } func buildQueryString(query url.Values, v reflect.Value, name string, tag reflect.StructTag) error { switch value := v.Interface().(type) { case []string: for _, item := range value { query.Add(name, item) } case map[string]string: for key, item := range value { query.Add(key, item) } case map[string][]string: for key, items := range value { for _, item := range items { query.Add(key, item) } } default: str, err := convertType(v, tag) if err == errValueNotSet { return nil } else if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to encode REST request", err) } query.Set(name, str) } return nil } func cleanPath(u url.URL) { hasSlash := strings.HasSuffix(u.Path, "/") // clean up path, removing duplicate `/` u.Path = path.Clean(u.Path) u.RawPath = path.Clean(u.RawPath) if hasSlash && !strings.HasSuffix(u.Path, "/") { u.Path += "/" u.RawPath += "/" } } // EscapePath escapes part of a URL path in Amazon style func EscapePath(path string, encodeSep bool) string { var buf bytes.Buffer for i := 0; i < len(path); i++ { c := path[i] if noEscape[c] \|\| (c == '/' && !encodeSep) { buf.WriteByte(c) } else { fmt.Fprintf(&buf, "%%%02X", c) } } return buf.String() } func convertType(v reflect.Value, tag reflect.StructTag) (str string, err error) { v = reflect.Indirect(v) if !v.IsValid() { return "", errValueNotSet } switch value := v.Interface().(type) { case string: if tag.Get("suppressedJSONValue") == "true" && tag.Get("location") == "header" { value = base64.StdEncoding.EncodeToString([]byte(value)) } str = value case []string: if tag.Get("location") != "header" \|\| tag.Get("enum") == "" { return "", fmt.Errorf("%T is only supported with location header and enum shapes", value) } if len(value) == 0 { return "", errValueNotSet } buff := &bytes.Buffer{} for i, sv := range value { if sv == nil \|\| len(sv) == 0 { continue } if i != 0 { buff.WriteRune(',') } item := *sv if strings.Index(item, `,`) != -1 \|\| strings.Index(item, `"`) != -1 { item = strconv.Quote(item) } buff.WriteString(item) } str = string(buff.Bytes()) case []byte: str = base64.StdEncoding.EncodeToString(value) case bool: str = strconv.FormatBool(value) case int64: str = strconv.FormatInt(value, 10) case float64: switch { case math.IsNaN(value): str = floatNaN case math.IsInf(value, 1): str = floatInf case math.IsInf(value, -1): str = floatNegInf default: str = strconv.FormatFloat(value, 'f', -1, 64) } case time.Time: format := tag.Get("timestampFormat") if len(format) == 0 { format = protocol.RFC822TimeFormatName if tag.Get("location") == "querystring" { format = protocol.ISO8601TimeFormatName } } str = protocol.FormatTime(format, value) case aws.JSONValue: if len(value) == 0 { return "", errValueNotSet } escaping := protocol.NoEscape if tag.Get("location") == "header" { escaping = protocol.Base64Escape } str, err = protocol.EncodeJSONValue(value, escaping) if err != nil { return "", fmt.Errorf("unable to encode JSONValue, %v", err) } default: err := fmt.Errorf("unsupported value for param %v (%s)", v.Interface(), v.Type()) return "", err } return str, nil }	8.92 KB	2025-05-25 12:27
📄 build_test.go //go:build go1.7 // +build go1.7 package rest import ( "math" "net/http" "net/url" "reflect" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/request" ) func TestCleanPath(t testing.T) { uri := &url.URL{ Path: "//foo//bar", Scheme: "https", Host: "host", } cleanPath(uri) expected := "https://host/foo/bar" if a, e := uri.String(), expected; a != e { t.Errorf("expect %q URI, got %q", e, a) } } func TestMarshalPath(t testing.T) { in := struct { Bucket string `location:"uri" locationName:"bucket"` Key string `location:"uri" locationName:"key"` }{ Bucket: aws.String("mybucket"), Key: aws.String("my/cool+thing space/object世界"), } expectURL := `/mybucket/my/cool+thing space/object世界` expectEscapedURL := `/mybucket/my/cool%2Bthing%20space/object%E4%B8%96%E7%95%8C` req := &request.Request{ HTTPRequest: &http.Request{ URL: &url.URL{Scheme: "https", Host: "example.com", Path: "/{bucket}/{key+}"}, }, Params: &in, } Build(req) if req.Error != nil { t.Fatalf("unexpected error, %v", req.Error) } if a, e := req.HTTPRequest.URL.Path, expectURL; a != e { t.Errorf("expect %q URI, got %q", e, a) } if a, e := req.HTTPRequest.URL.RawPath, expectEscapedURL; a != e { t.Errorf("expect %q escaped URI, got %q", e, a) } if a, e := req.HTTPRequest.URL.EscapedPath(), expectEscapedURL; a != e { t.Errorf("expect %q escaped URI, got %q", e, a) } } func TestListOfEnums(t testing.T) { cases := []struct { Input interface{} Expected http.Header WantErr bool }{ { Input: func() interface{} { type v struct { List []string `type:"list" location:"header" locationName:"x-amz-test-header"` } return &v{ List: []string{aws.String("foo")}, } }(), WantErr: true, }, { Input: func() interface{} { type v struct { List []string `type:"list" location:"uri" locationName:"someList"` } return &v{ List: []string{aws.String("foo")}, } }(), WantErr: true, }, { Input: func() interface{} { type v struct { List map[string][]string `type:"map" location:"headers" locationName:"x-amz-metadata"` } return &v{ List: map[string][]string{ "foo": {aws.String("foo")}, }, } }(), WantErr: true, }, { Input: func() interface{} { type v struct { List []string `type:"list" location:"header" locationName:"x-amz-test-header" enum:"FooBar"` } return &v{ List: []string{aws.String("foo")}, } }(), Expected: http.Header{ "X-Amz-Test-Header": {"foo"}, }, }, { Input: func() interface{} { type v struct { List []string `type:"list" location:"header" locationName:"x-amz-test-header" enum:"FooBar"` } return &v{ List: []string{aws.String("foo"), nil, aws.String(""), nil, aws.String("bar")}, } }(), Expected: http.Header{ "X-Amz-Test-Header": {"foo,bar"}, }, }, { Input: func() interface{} { type v struct { List []string `type:"list" location:"header" locationName:"x-amz-test-header" enum:"FooBar"` } return &v{ List: []string{aws.String("f,o,o"), nil, aws.String(""), nil, aws.String(`"bar"`)}, } }(), Expected: http.Header{ "X-Amz-Test-Header": {`"f,o,o","\"bar\""`}, }, }, { Input: func() interface{} { type v struct { List []string `type:"list" location:"header" locationName:"x-amz-test-header" enum:"FooBar"` } return &v{ List: nil, } }(), Expected: http.Header{}, }, { Input: func() interface{} { type v struct { List []string `type:"list" location:"header" locationName:"x-amz-test-header" enum:"FooBar"` } return &v{ List: []string{}, } }(), Expected: http.Header{}, }, } for i, tt := range cases { req := &request.Request{ HTTPRequest: &http.Request{ URL: func() url.URL { u, err := url.Parse("https://foo.amazonaws.com") if err != nil { panic(err) } return u }(), Header: map[string][]string{}, }, Params: tt.Input, } Build(req) if (req.Error != nil) != (tt.WantErr) { t.Fatalf("(%d) WantErr(%t) got %v", i, tt.WantErr, req.Error) } if tt.WantErr { continue } if e, a := tt.Expected, req.HTTPRequest.Header; !reflect.DeepEqual(e, a) { t.Errorf("(%d) expect %v, got %v", i, e, a) } } } func TestMarshalFloat64(t testing.T) { cases := map[string]struct { Input interface{} URL string ExpectedHeader http.Header ExpectedURL string WantErr bool }{ "header float values": { Input: &struct { Float float64 `location:"header" locationName:"x-amz-float"` FloatInf float64 `location:"header" locationName:"x-amz-float-inf"` FloatNegInf float64 `location:"header" locationName:"x-amz-float-neg-inf"` FloatNaN float64 `location:"header" locationName:"x-amz-float-nan"` }{ Float: aws.Float64(123456789.123), FloatInf: aws.Float64(math.Inf(1)), FloatNegInf: aws.Float64(math.Inf(-1)), FloatNaN: aws.Float64(math.NaN()), }, URL: "https://example.com/", ExpectedHeader: map[string][]string{ "X-Amz-Float": {"123456789.123"}, "X-Amz-Float-Inf": {"Infinity"}, "X-Amz-Float-Neg-Inf": {"-Infinity"}, "X-Amz-Float-Nan": {"NaN"}, }, ExpectedURL: "https://example.com/", }, "path float values": { Input: &struct { Float float64 `location:"uri" locationName:"float"` FloatInf float64 `location:"uri" locationName:"floatInf"` FloatNegInf float64 `location:"uri" locationName:"floatNegInf"` FloatNaN float64 `location:"uri" locationName:"floatNaN"` }{ Float: aws.Float64(123456789.123), FloatInf: aws.Float64(math.Inf(1)), FloatNegInf: aws.Float64(math.Inf(-1)), FloatNaN: aws.Float64(math.NaN()), }, URL: "https://example.com/{float}/{floatInf}/{floatNegInf}/{floatNaN}", ExpectedHeader: map[string][]string{}, ExpectedURL: "https://example.com/123456789.123/Infinity/-Infinity/NaN", }, "query float values": { Input: &struct { Float float64 `location:"querystring" locationName:"x-amz-float"` FloatInf float64 `location:"querystring" locationName:"x-amz-float-inf"` FloatNegInf float64 `location:"querystring" locationName:"x-amz-float-neg-inf"` FloatNaN float64 `location:"querystring" locationName:"x-amz-float-nan"` }{ Float: aws.Float64(123456789.123), FloatInf: aws.Float64(math.Inf(1)), FloatNegInf: aws.Float64(math.Inf(-1)), FloatNaN: aws.Float64(math.NaN()), }, URL: "https://example.com/", ExpectedHeader: map[string][]string{}, ExpectedURL: "https://example.com/?x-amz-float=123456789.123&x-amz-float-inf=Infinity&x-amz-float-nan=NaN&x-amz-float-neg-inf=-Infinity", }, } for name, tt := range cases { t.Run(name, func(t testing.T) { req := &request.Request{ HTTPRequest: &http.Request{ URL: func() url.URL { u, err := url.Parse(tt.URL) if err != nil { panic(err) } return u }(), Header: map[string][]string{}, }, Params: tt.Input, } Build(req) if (req.Error != nil) != (tt.WantErr) { t.Fatalf("WantErr(%t) got %v", tt.WantErr, req.Error) } if tt.WantErr { return } if e, a := tt.ExpectedHeader, req.HTTPRequest.Header; !reflect.DeepEqual(e, a) { t.Errorf("expect %v, got %v", e, a) } if e, a := tt.ExpectedURL, req.HTTPRequest.URL.String(); e != a { t.Errorf("expect %v, got %v", e, a) } }) } }	7.52 KB	2025-05-25 12:27
📄 payload.go package rest import "reflect" // PayloadMember returns the payload field member of i if there is one, or nil. func PayloadMember(i interface{}) interface{} { if i == nil { return nil } v := reflect.ValueOf(i).Elem() if !v.IsValid() { return nil } if field, ok := v.Type().FieldByName("_"); ok { if payloadName := field.Tag.Get("payload"); payloadName != "" { field, _ := v.Type().FieldByName(payloadName) if field.Tag.Get("type") != "structure" { return nil } payload := v.FieldByName(payloadName) if payload.IsValid() \|\| (payload.Kind() == reflect.Ptr && !payload.IsNil()) { return payload.Interface() } } } return nil } const nopayloadPayloadType = "nopayload" // PayloadType returns the type of a payload field member of i if there is one, // or "". func PayloadType(i interface{}) string { v := reflect.Indirect(reflect.ValueOf(i)) if !v.IsValid() { return "" } if field, ok := v.Type().FieldByName("_"); ok { if noPayload := field.Tag.Get(nopayloadPayloadType); noPayload != "" { return nopayloadPayloadType } if payloadName := field.Tag.Get("payload"); payloadName != "" { if member, ok := v.Type().FieldByName(payloadName); ok { return member.Tag.Get("type") } } } return "" }	1.23 KB	2025-05-25 12:27
📄 rest_test.go //go:build go1.7 // +build go1.7 package rest_test import ( "bytes" "io/ioutil" "net/http" "reflect" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/client" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/signer/v4" "github.com/aws/aws-sdk-go/awstesting/unit" "github.com/aws/aws-sdk-go/private/protocol/rest" ) func TestUnsetHeaders(t testing.T) { cfg := &aws.Config{Region: aws.String("us-west-2")} c := unit.Session.ClientConfig("testService", cfg) svc := client.New( cfg, metadata.ClientInfo{ ServiceName: "testService", SigningName: c.SigningName, SigningRegion: c.SigningRegion, Endpoint: c.Endpoint, APIVersion: "", }, c.Handlers, ) // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(rest.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(rest.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(rest.UnmarshalMetaHandler) op := &request.Operation{ Name: "test-operation", HTTPPath: "/", } input := &struct { Foo aws.JSONValue `location:"header" locationName:"x-amz-foo" type:"jsonvalue"` Bar aws.JSONValue `location:"header" locationName:"x-amz-bar" type:"jsonvalue"` }{} output := &struct { Foo aws.JSONValue `location:"header" locationName:"x-amz-foo" type:"jsonvalue"` Bar aws.JSONValue `location:"header" locationName:"x-amz-bar" type:"jsonvalue"` }{} req := svc.NewRequest(op, input, output) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewBuffer(nil)), Header: http.Header{}} req.HTTPResponse.Header.Set("X-Amz-Foo", "e30=") // unmarshal response rest.UnmarshalMeta(req) rest.Unmarshal(req) if req.Error != nil { t.Fatal(req.Error) } } func TestNormalizedHeaders(t testing.T) { cases := map[string]struct { inputValues map[string]string outputValues http.Header expectedInputHeaders http.Header expectedOutput map[string]string normalize bool }{ "non-normalized headers": { inputValues: map[string]string{ "baz": aws.String("bazValue"), "BAR": aws.String("barValue"), }, expectedInputHeaders: http.Header{ "X-Amz-Meta-Baz": []string{"bazValue"}, "X-Amz-Meta-Bar": []string{"barValue"}, }, outputValues: http.Header{ "X-Amz-Meta-Baz": []string{"bazValue"}, "X-Amz-Meta-Bar": []string{"barValue"}, }, expectedOutput: map[string]string{ "Baz": aws.String("bazValue"), "Bar": aws.String("barValue"), }, }, "normalized headers": { inputValues: map[string]string{ "baz": aws.String("bazValue"), "BAR": aws.String("barValue"), }, expectedInputHeaders: http.Header{ "X-Amz-Meta-Baz": []string{"bazValue"}, "X-Amz-Meta-Bar": []string{"barValue"}, }, outputValues: http.Header{ "X-Amz-Meta-Baz": []string{"bazValue"}, "X-Amz-Meta-Bar": []string{"barValue"}, }, expectedOutput: map[string]string{ "baz": aws.String("bazValue"), "bar": aws.String("barValue"), }, normalize: true, }, } for name, tt := range cases { t.Run(name, func(t testing.T) { cfg := &aws.Config{Region: aws.String("us-west-2"), LowerCaseHeaderMaps: &tt.normalize} c := unit.Session.ClientConfig("testService", cfg) svc := client.New( cfg, metadata.ClientInfo{ ServiceName: "testService", SigningName: c.SigningName, SigningRegion: c.SigningRegion, Endpoint: c.Endpoint, APIVersion: "", }, c.Handlers, ) // Handlers op := &request.Operation{ Name: "test-operation", HTTPPath: "/", } input := &struct { Foo map[string]string `location:"headers" locationName:"x-amz-meta-" type:"map"` }{ Foo: tt.inputValues, } output := &struct { Foo map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"` }{} req := svc.NewRequest(op, input, output) req.HTTPResponse = &http.Response{ StatusCode: 200, Body: ioutil.NopCloser(bytes.NewBuffer(nil)), Header: tt.outputValues, } // Build Request rest.Build(req) if req.Error != nil { t.Fatal(req.Error) } if e, a := tt.expectedInputHeaders, req.HTTPRequest.Header; !reflect.DeepEqual(e, a) { t.Errorf("expected %v, but got %v", e, a) } // unmarshal response rest.UnmarshalMeta(req) rest.Unmarshal(req) if req.Error != nil { t.Fatal(req.Error) } if e, a := tt.expectedOutput, output.Foo; !reflect.DeepEqual(e, a) { t.Errorf("expected %v, but got %v", e, a) } }) } }	4.56 KB	2025-05-25 12:27
📄 unmarshal.go package rest import ( "bytes" "encoding/base64" "fmt" "io" "io/ioutil" "math" "net/http" "reflect" "strconv" "strings" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" awsStrings "github.com/aws/aws-sdk-go/internal/strings" "github.com/aws/aws-sdk-go/private/protocol" ) // UnmarshalHandler is a named request handler for unmarshaling rest protocol requests var UnmarshalHandler = request.NamedHandler{Name: "awssdk.rest.Unmarshal", Fn: Unmarshal} // UnmarshalMetaHandler is a named request handler for unmarshaling rest protocol request metadata var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.rest.UnmarshalMeta", Fn: UnmarshalMeta} // Unmarshal unmarshals the REST component of a response in a REST service. func Unmarshal(r request.Request) { if r.DataFilled() { v := reflect.Indirect(reflect.ValueOf(r.Data)) if err := unmarshalBody(r, v); err != nil { r.Error = err } } } // UnmarshalMeta unmarshals the REST metadata of a response in a REST service func UnmarshalMeta(r request.Request) { r.RequestID = r.HTTPResponse.Header.Get("X-Amzn-Requestid") if r.RequestID == "" { // Alternative version of request id in the header r.RequestID = r.HTTPResponse.Header.Get("X-Amz-Request-Id") } if r.DataFilled() { if err := UnmarshalResponse(r.HTTPResponse, r.Data, aws.BoolValue(r.Config.LowerCaseHeaderMaps)); err != nil { r.Error = err } } } // UnmarshalResponse attempts to unmarshal the REST response headers to // the data type passed in. The type must be a pointer. An error is returned // with any error unmarshaling the response into the target datatype. func UnmarshalResponse(resp http.Response, data interface{}, lowerCaseHeaderMaps bool) error { v := reflect.Indirect(reflect.ValueOf(data)) return unmarshalLocationElements(resp, v, lowerCaseHeaderMaps) } func unmarshalBody(r request.Request, v reflect.Value) error { if field, ok := v.Type().FieldByName("_"); ok { if payloadName := field.Tag.Get("payload"); payloadName != "" { pfield, _ := v.Type().FieldByName(payloadName) if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" { payload := v.FieldByName(payloadName) if payload.IsValid() { switch payload.Interface().(type) { case []byte: defer r.HTTPResponse.Body.Close() b, err := ioutil.ReadAll(r.HTTPResponse.Body) if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to decode REST response", err) } payload.Set(reflect.ValueOf(b)) case string: defer r.HTTPResponse.Body.Close() b, err := ioutil.ReadAll(r.HTTPResponse.Body) if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to decode REST response", err) } str := string(b) payload.Set(reflect.ValueOf(&str)) default: switch payload.Type().String() { case "io.ReadCloser": payload.Set(reflect.ValueOf(r.HTTPResponse.Body)) case "io.ReadSeeker": b, err := ioutil.ReadAll(r.HTTPResponse.Body) if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to read response body", err) } payload.Set(reflect.ValueOf(ioutil.NopCloser(bytes.NewReader(b)))) default: io.Copy(ioutil.Discard, r.HTTPResponse.Body) r.HTTPResponse.Body.Close() return awserr.New(request.ErrCodeSerialization, "failed to decode REST response", fmt.Errorf("unknown payload type %s", payload.Type())) } } } } } } return nil } func unmarshalLocationElements(resp http.Response, v reflect.Value, lowerCaseHeaderMaps bool) error { for i := 0; i < v.NumField(); i++ { m, field := v.Field(i), v.Type().Field(i) if n := field.Name; n[0:1] == strings.ToLower(n[0:1]) { continue } if m.IsValid() { name := field.Tag.Get("locationName") if name == "" { name = field.Name } switch field.Tag.Get("location") { case "statusCode": unmarshalStatusCode(m, resp.StatusCode) case "header": err := unmarshalHeader(m, resp.Header.Get(name), field.Tag) if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to decode REST response", err) } case "headers": prefix := field.Tag.Get("locationName") err := unmarshalHeaderMap(m, resp.Header, prefix, lowerCaseHeaderMaps) if err != nil { return awserr.New(request.ErrCodeSerialization, "failed to decode REST response", err) } } } } return nil } func unmarshalStatusCode(v reflect.Value, statusCode int) { if !v.IsValid() { return } switch v.Interface().(type) { case int64: s := int64(statusCode) v.Set(reflect.ValueOf(&s)) } } func unmarshalHeaderMap(r reflect.Value, headers http.Header, prefix string, normalize bool) error { if len(headers) == 0 { return nil } switch r.Interface().(type) { case map[string]string: // we only support string map value types out := map[string]string{} for k, v := range headers { if awsStrings.HasPrefixFold(k, prefix) { if normalize == true { k = strings.ToLower(k) } else { k = http.CanonicalHeaderKey(k) } out[k[len(prefix):]] = &v[0] } } if len(out) != 0 { r.Set(reflect.ValueOf(out)) } } return nil } func unmarshalHeader(v reflect.Value, header string, tag reflect.StructTag) error { switch tag.Get("type") { case "jsonvalue": if len(header) == 0 { return nil } case "blob": if len(header) == 0 { return nil } default: if !v.IsValid() \|\| (header == "" && v.Elem().Kind() != reflect.String) { return nil } } switch v.Interface().(type) { case string: if tag.Get("suppressedJSONValue") == "true" && tag.Get("location") == "header" { b, err := base64.StdEncoding.DecodeString(header) if err != nil { return fmt.Errorf("failed to decode JSONValue, %v", err) } header = string(b) } v.Set(reflect.ValueOf(&header)) case []byte: b, err := base64.StdEncoding.DecodeString(header) if err != nil { return err } v.Set(reflect.ValueOf(b)) case bool: b, err := strconv.ParseBool(header) if err != nil { return err } v.Set(reflect.ValueOf(&b)) case int64: i, err := strconv.ParseInt(header, 10, 64) if err != nil { return err } v.Set(reflect.ValueOf(&i)) case float64: var f float64 switch { case strings.EqualFold(header, floatNaN): f = math.NaN() case strings.EqualFold(header, floatInf): f = math.Inf(1) case strings.EqualFold(header, floatNegInf): f = math.Inf(-1) default: var err error f, err = strconv.ParseFloat(header, 64) if err != nil { return err } } v.Set(reflect.ValueOf(&f)) case time.Time: format := tag.Get("timestampFormat") if len(format) == 0 { format = protocol.RFC822TimeFormatName } t, err := protocol.ParseTime(format, header) if err != nil { return err } v.Set(reflect.ValueOf(&t)) case aws.JSONValue: escaping := protocol.NoEscape if tag.Get("location") == "header" { escaping = protocol.Base64Escape } m, err := protocol.DecodeJSONValue(header, escaping) if err != nil { return err } v.Set(reflect.ValueOf(m)) default: err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type()) return err } return nil }	7.21 KB	2025-05-25 12:27
📄 unmarshal_test.go //go:build go1.7 // +build go1.7 package rest import ( "bytes" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/request" "io/ioutil" "math" "net/http" "reflect" "testing" ) func TestUnmarshalFloat64(t testing.T) { cases := map[string]struct { Headers http.Header OutputFn func() (interface{}, func(testing.T, interface{})) WantErr bool }{ "header float values": { OutputFn: func() (interface{}, func(testing.T, interface{})) { type output struct { Float float64 `location:"header" locationName:"x-amz-float"` FloatInf float64 `location:"header" locationName:"x-amz-float-inf"` FloatNegInf float64 `location:"header" locationName:"x-amz-float-neg-inf"` FloatNaN float64 `location:"header" locationName:"x-amz-float-nan"` } return &output{}, func(t testing.T, out interface{}) { o, ok := out.(output) if !ok { t.Errorf("expect %T, got %T", (output)(nil), out) } if e, a := aws.Float64(123456789.123), o.Float; !reflect.DeepEqual(e, a) { t.Errorf("expect %v, got %v", e, a) } if a := aws.Float64Value(o.FloatInf); !math.IsInf(a, 1) { t.Errorf("expect infinity, got %v", a) } if a := aws.Float64Value(o.FloatNegInf); !math.IsInf(a, -1) { t.Errorf("expect infinity, got %v", a) } if a := aws.Float64Value(o.FloatNaN); !math.IsNaN(a) { t.Errorf("expect infinity, got %v", a) } } }, Headers: map[string][]string{ "X-Amz-Float": {"123456789.123"}, "X-Amz-Float-Inf": {"Infinity"}, "X-Amz-Float-Neg-Inf": {"-Infinity"}, "X-Amz-Float-Nan": {"NaN"}, }, }, } for name, tt := range cases { t.Run(name, func(t *testing.T) { output, expectFn := tt.OutputFn() req := &request.Request{ Data: output, HTTPResponse: &http.Response{ StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader(nil)), Header: tt.Headers, }, } if (req.Error != nil) != tt.WantErr { t.Fatalf("WantErr(%v) != %v", tt.WantErr, req.Error) } if tt.WantErr { return } UnmarshalMeta(req) expectFn(t, output) }) } }	2.13 KB	2025-05-25 12:27

Terminal