Wala shell

Advanced PHP File Manager

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

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📁 ec2query	-	2025-05-25 12:27
📁 eventstream	-	2025-05-25 12:27
📄 host.go package protocol import ( "github.com/aws/aws-sdk-go/aws/request" "net" "strconv" "strings" ) // ValidateEndpointHostHandler is a request handler that will validate the // request endpoint's hosts is a valid RFC 3986 host. var ValidateEndpointHostHandler = request.NamedHandler{ Name: "awssdk.protocol.ValidateEndpointHostHandler", Fn: func(r *request.Request) { err := ValidateEndpointHost(r.Operation.Name, r.HTTPRequest.URL.Host) if err != nil { r.Error = err } }, } // ValidateEndpointHost validates that the host string passed in is a valid RFC // 3986 host. Returns error if the host is not valid. func ValidateEndpointHost(opName, host string) error { paramErrs := request.ErrInvalidParams{Context: opName} var hostname string var port string var err error if strings.Contains(host, ":") { hostname, port, err = net.SplitHostPort(host) if err != nil { paramErrs.Add(request.NewErrParamFormat("endpoint", err.Error(), host)) } if !ValidPortNumber(port) { paramErrs.Add(request.NewErrParamFormat("endpoint port number", "[0-65535]", port)) } } else { hostname = host } labels := strings.Split(hostname, ".") for i, label := range labels { if i == len(labels)-1 && len(label) == 0 { // Allow trailing dot for FQDN hosts. continue } if !ValidHostLabel(label) { paramErrs.Add(request.NewErrParamFormat( "endpoint host label", "[a-zA-Z0-9-]{1,63}", label)) } } if len(hostname) == 0 { paramErrs.Add(request.NewErrParamMinLen("endpoint host", 1)) } if len(hostname) > 255 { paramErrs.Add(request.NewErrParamMaxLen( "endpoint host", 255, host, )) } if paramErrs.Len() > 0 { return paramErrs } return nil } // ValidHostLabel returns if the label is a valid RFC 3986 host label. func ValidHostLabel(label string) bool { if l := len(label); l == 0 \|\| l > 63 { return false } for _, r := range label { switch { case r >= '0' && r <= '9': case r >= 'A' && r <= 'Z': case r >= 'a' && r <= 'z': case r == '-': default: return false } } return true } // ValidPortNumber return if the port is valid RFC 3986 port func ValidPortNumber(port string) bool { i, err := strconv.Atoi(port) if err != nil { return false } if i < 0 \|\| i > 65535 { return false } return true }	2.24 KB	2025-05-25 12:27
📄 host_prefix.go package protocol import ( "strings" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/request" ) // HostPrefixHandlerName is the handler name for the host prefix request // handler. const HostPrefixHandlerName = "awssdk.endpoint.HostPrefixHandler" // NewHostPrefixHandler constructs a build handler func NewHostPrefixHandler(prefix string, labelsFn func() map[string]string) request.NamedHandler { builder := HostPrefixBuilder{ Prefix: prefix, LabelsFn: labelsFn, } return request.NamedHandler{ Name: HostPrefixHandlerName, Fn: builder.Build, } } // HostPrefixBuilder provides the request handler to expand and prepend // the host prefix into the operation's request endpoint host. type HostPrefixBuilder struct { Prefix string LabelsFn func() map[string]string } // Build updates the passed in Request with the HostPrefix template expanded. func (h HostPrefixBuilder) Build(r *request.Request) { if aws.BoolValue(r.Config.DisableEndpointHostPrefix) { return } var labels map[string]string if h.LabelsFn != nil { labels = h.LabelsFn() } prefix := h.Prefix for name, value := range labels { prefix = strings.Replace(prefix, "{"+name+"}", value, -1) } r.HTTPRequest.URL.Host = prefix + r.HTTPRequest.URL.Host if len(r.HTTPRequest.Host) > 0 { r.HTTPRequest.Host = prefix + r.HTTPRequest.Host } }	1.33 KB	2025-05-25 12:27
📄 host_prefix_test.go //go:build go1.7 // +build go1.7 package protocol import ( "net/http" "net/url" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/request" ) func TestHostPrefixBuilder(t testing.T) { cases := map[string]struct { URLHost string ReqHost string Prefix string LabelsFn func() map[string]string Disabled bool ExpectURLHost string ExpectReqHost string }{ "no labels": { URLHost: "service.region.amazonaws.com", Prefix: "data-", ExpectURLHost: "data-service.region.amazonaws.com", }, "with labels": { URLHost: "service.region.amazonaws.com", Prefix: "{first}-{second}.", LabelsFn: func() map[string]string { return map[string]string{ "first": "abc", "second": "123", } }, ExpectURLHost: "abc-123.service.region.amazonaws.com", }, "with host prefix disabled": { Disabled: true, URLHost: "service.region.amazonaws.com", Prefix: "{first}-{second}.", LabelsFn: func() map[string]string { return map[string]string{ "first": "abc", "second": "123", } }, ExpectURLHost: "service.region.amazonaws.com", }, "with duplicate labels": { URLHost: "service.region.amazonaws.com", Prefix: "{first}-{second}-{first}.", LabelsFn: func() map[string]string { return map[string]string{ "first": "abc", "second": "123", } }, ExpectURLHost: "abc-123-abc.service.region.amazonaws.com", }, "with unbracketed labels": { URLHost: "service.region.amazonaws.com", Prefix: "first-{second}.", LabelsFn: func() map[string]string { return map[string]string{ "first": "abc", "second": "123", } }, ExpectURLHost: "first-123.service.region.amazonaws.com", }, "with req host": { URLHost: "service.region.amazonaws.com:1234", ReqHost: "service.region.amazonaws.com", Prefix: "data-", ExpectURLHost: "data-service.region.amazonaws.com:1234", ExpectReqHost: "data-service.region.amazonaws.com", }, } for name, c := range cases { t.Run(name, func(t testing.T) { builder := HostPrefixBuilder{ Prefix: c.Prefix, LabelsFn: c.LabelsFn, } req := &request.Request{ Config: aws.Config{ DisableEndpointHostPrefix: aws.Bool(c.Disabled), }, HTTPRequest: &http.Request{ Host: c.ReqHost, URL: &url.URL{ Host: c.URLHost, }, }, } builder.Build(req) if e, a := c.ExpectURLHost, req.HTTPRequest.URL.Host; e != a { t.Errorf("expect URL host %v, got %v", e, a) } if e, a := c.ExpectReqHost, req.HTTPRequest.Host; e != a { t.Errorf("expect request host %v, got %v", e, a) } }) } }	2.62 KB	2025-05-25 12:27
📄 host_test.go //go:build go1.7 // +build go1.7 package protocol import ( "strconv" "testing" ) func TestValidPortNumber(t testing.T) { cases := []struct { Input string Valid bool }{ {Input: "123", Valid: true}, {Input: "123.0", Valid: false}, {Input: "-123", Valid: false}, {Input: "65536", Valid: false}, {Input: "0", Valid: true}, } for i, c := range cases { t.Run(strconv.Itoa(i), func(t testing.T) { valid := ValidPortNumber(c.Input) if e, a := c.Valid, valid; e != a { t.Errorf("expect valid %v, got %v", e, a) } }) } } func TestValidHostLabel(t testing.T) { cases := []struct { Input string Valid bool }{ {Input: "abc123", Valid: true}, {Input: "123", Valid: true}, {Input: "abc", Valid: true}, {Input: "123-abc", Valid: true}, {Input: "{thing}-abc", Valid: false}, {Input: "abc.123", Valid: false}, {Input: "abc/123", Valid: false}, {Input: "012345678901234567890123456789012345678901234567890123456789123", Valid: true}, {Input: "0123456789012345678901234567890123456789012345678901234567891234", Valid: false}, {Input: "", Valid: false}, } for i, c := range cases { t.Run(strconv.Itoa(i), func(t testing.T) { valid := ValidHostLabel(c.Input) if e, a := c.Valid, valid; e != a { t.Errorf("expect valid %v, got %v", e, a) } }) } } func TestValidateEndpointHostHandler(t testing.T) { cases := map[string]struct { Input string Valid bool }{ "valid host": {Input: "abc.123", Valid: true}, "fqdn host": {Input: "abc.123.", Valid: true}, "empty label": {Input: "abc..", Valid: false}, "max host len": { Input: "123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.12345", Valid: true, }, "too long host": { Input: "123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456", Valid: false, }, "valid host with port number": {Input: "abd.123:1234", Valid: true}, "valid host with invalid port number": {Input: "abc.123:99999", Valid: false}, "empty host with port number": {Input: ":1234", Valid: false}, "valid host with empty port number": {Input: "abc.123:", Valid: false}, } for name, c := range cases { t.Run(name, func(t testing.T) { err := ValidateEndpointHost("OpName", c.Input) if e, a := c.Valid, err == nil; e != a { t.Errorf("expect valid %v, got %v, %v", e, a, err) } }) } }	2.68 KB	2025-05-25 12:27
📄 idempotency.go package protocol import ( "crypto/rand" "fmt" "reflect" ) // RandReader is the random reader the protocol package will use to read // random bytes from. This is exported for testing, and should not be used. var RandReader = rand.Reader const idempotencyTokenFillTag = `idempotencyToken` // CanSetIdempotencyToken returns true if the struct field should be // automatically populated with a Idempotency token. // // Only string and string type fields that are tagged with idempotencyToken // which are not already set can be auto filled. func CanSetIdempotencyToken(v reflect.Value, f reflect.StructField) bool { switch u := v.Interface().(type) { // To auto fill an Idempotency token the field must be a string, // tagged for auto fill, and have a zero value. case string: return u == nil && len(f.Tag.Get(idempotencyTokenFillTag)) != 0 case string: return len(u) == 0 && len(f.Tag.Get(idempotencyTokenFillTag)) != 0 } return false } // GetIdempotencyToken returns a randomly generated idempotency token. func GetIdempotencyToken() string { b := make([]byte, 16) RandReader.Read(b) return UUIDVersion4(b) } // SetIdempotencyToken will set the value provided with a Idempotency Token. // Given that the value can be set. Will panic if value is not setable. func SetIdempotencyToken(v reflect.Value) { if v.Kind() == reflect.Ptr { if v.IsNil() && v.CanSet() { v.Set(reflect.New(v.Type().Elem())) } v = v.Elem() } v = reflect.Indirect(v) if !v.CanSet() { panic(fmt.Sprintf("unable to set idempotnecy token %v", v)) } b := make([]byte, 16) _, err := rand.Read(b) if err != nil { // TODO handle error return } v.Set(reflect.ValueOf(UUIDVersion4(b))) } // UUIDVersion4 returns a Version 4 random UUID from the byte slice provided func UUIDVersion4(u []byte) string { // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_.28random.29 // 13th character is "4" u[6] = (u[6] \| 0x40) & 0x4F // 17th character is "8", "9", "a", or "b" u[8] = (u[8] \| 0x80) & 0xBF return fmt.Sprintf(`%X-%X-%X-%X-%X`, u[0:4], u[4:6], u[6:8], u[8:10], u[10:]) }	2.06 KB	2025-05-25 12:27
📄 idempotency_test.go package protocol_test import ( "reflect" "testing" "github.com/aws/aws-sdk-go/private/protocol" ) func TestCanSetIdempotencyToken(t testing.T) { cases := []struct { CanSet bool Case interface{} }{ { true, struct { Field string `idempotencyToken:"true"` }{}, }, { true, struct { Field string `idempotencyToken:"true"` }{}, }, { false, struct { Field string `idempotencyToken:"true"` }{Field: new(string)}, }, { false, struct { Field string `idempotencyToken:"true"` }{Field: "value"}, }, { false, struct { Field int `idempotencyToken:"true"` }{}, }, { false, struct { Field string }{}, }, } for i, c := range cases { v := reflect.Indirect(reflect.ValueOf(c.Case)) ty := v.Type() canSet := protocol.CanSetIdempotencyToken(v.Field(0), ty.Field(0)) if e, a := c.CanSet, canSet; e != a { t.Errorf("%d, expect %v, got %v", i, e, a) } } } func TestSetIdempotencyToken(t testing.T) { cases := []struct { Case interface{} }{ { &struct { Field string `idempotencyToken:"true"` }{}, }, { &struct { Field string `idempotencyToken:"true"` }{}, }, { &struct { Field string `idempotencyToken:"true"` }{Field: new(string)}, }, { &struct { Field string `idempotencyToken:"true"` }{Field: ""}, }, } for i, c := range cases { v := reflect.Indirect(reflect.ValueOf(c.Case)) protocol.SetIdempotencyToken(v.Field(0)) if v.Field(0).Interface() == nil { t.Errorf("%d, expect not nil", i) } } } func TestUUIDVersion4(t *testing.T) { uuid := protocol.UUIDVersion4(make([]byte, 16)) if e, a := `00000000-0000-4000-8000-000000000000`, uuid; e != a { t.Errorf("expect %v, got %v", e, a) } b := make([]byte, 16) for i := 0; i < len(b); i++ { b[i] = 1 } uuid = protocol.UUIDVersion4(b) if e, a := `01010101-0101-4101-8101-010101010101`, uuid; e != a { t.Errorf("expect %v, got %v", e, a) } }	1.95 KB	2025-05-25 12:27
📁 json	-	2025-05-25 12:27
📁 jsonrpc	-	2025-05-25 12:27
📄 jsonvalue.go package protocol import ( "encoding/base64" "encoding/json" "fmt" "strconv" "github.com/aws/aws-sdk-go/aws" ) // EscapeMode is the mode that should be use for escaping a value type EscapeMode uint // The modes for escaping a value before it is marshaled, and unmarshaled. const ( NoEscape EscapeMode = iota Base64Escape QuotedEscape ) // EncodeJSONValue marshals the value into a JSON string, and optionally base64 // encodes the string before returning it. // // Will panic if the escape mode is unknown. func EncodeJSONValue(v aws.JSONValue, escape EscapeMode) (string, error) { b, err := json.Marshal(v) if err != nil { return "", err } switch escape { case NoEscape: return string(b), nil case Base64Escape: return base64.StdEncoding.EncodeToString(b), nil case QuotedEscape: return strconv.Quote(string(b)), nil } panic(fmt.Sprintf("EncodeJSONValue called with unknown EscapeMode, %v", escape)) } // DecodeJSONValue will attempt to decode the string input as a JSONValue. // Optionally decoding base64 the value first before JSON unmarshaling. // // Will panic if the escape mode is unknown. func DecodeJSONValue(v string, escape EscapeMode) (aws.JSONValue, error) { var b []byte var err error switch escape { case NoEscape: b = []byte(v) case Base64Escape: b, err = base64.StdEncoding.DecodeString(v) case QuotedEscape: var u string u, err = strconv.Unquote(v) b = []byte(u) default: panic(fmt.Sprintf("DecodeJSONValue called with unknown EscapeMode, %v", escape)) } if err != nil { return nil, err } m := aws.JSONValue{} err = json.Unmarshal(b, &m) if err != nil { return nil, err } return m, nil }	1.63 KB	2025-05-25 12:27
📄 jsonvalue_test.go package protocol import ( "fmt" "reflect" "strings" "testing" "github.com/aws/aws-sdk-go/aws" ) var testJSONValueCases = []struct { Value aws.JSONValue Mode EscapeMode String string }{ { Value: aws.JSONValue{ "abc": 123., }, Mode: NoEscape, String: `{"abc":123}`, }, { Value: aws.JSONValue{ "abc": 123., }, Mode: Base64Escape, String: `eyJhYmMiOjEyM30=`, }, { Value: aws.JSONValue{ "abc": 123., }, Mode: QuotedEscape, String: `"{\"abc\":123}"`, }, } func TestEncodeJSONValue(t testing.T) { for i, c := range testJSONValueCases { str, err := EncodeJSONValue(c.Value, c.Mode) if err != nil { t.Fatalf("%d, expect no error, got %v", i, err) } if e, a := c.String, str; e != a { t.Errorf("%d, expect %v encoded value, got %v", i, e, a) } } } func TestDecodeJSONValue(t testing.T) { for i, c := range testJSONValueCases { val, err := DecodeJSONValue(c.String, c.Mode) if err != nil { t.Fatalf("%d, expect no error, got %v", i, err) } if e, a := c.Value, val; !reflect.DeepEqual(e, a) { t.Errorf("%d, expect %v encoded value, got %v", i, e, a) } } } func TestEncodeJSONValue_PanicUnkownMode(t testing.T) { defer func() { if r := recover(); r == nil { t.Errorf("expect panic, got none") } else { reason := fmt.Sprintf("%v", r) if e, a := "unknown EscapeMode", reason; !strings.Contains(a, e) { t.Errorf("expect %q to be in %v", e, a) } } }() val := aws.JSONValue{} EncodeJSONValue(val, 123456) } func TestDecodeJSONValue_PanicUnkownMode(t testing.T) { defer func() { if r := recover(); r == nil { t.Errorf("expect panic, got none") } else { reason := fmt.Sprintf("%v", r) if e, a := "unknown EscapeMode", reason; !strings.Contains(a, e) { t.Errorf("expect %q to be in %v", e, a) } } }() DecodeJSONValue(`{"abc":123}`, 123456) }	1.83 KB	2025-05-25 12:27
📄 payload.go package protocol import ( "io" "io/ioutil" "net/http" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/request" ) // PayloadUnmarshaler provides the interface for unmarshaling a payload's // reader into a SDK shape. type PayloadUnmarshaler interface { UnmarshalPayload(io.Reader, interface{}) error } // HandlerPayloadUnmarshal implements the PayloadUnmarshaler from a // HandlerList. This provides the support for unmarshaling a payload reader to // a shape without needing a SDK request first. type HandlerPayloadUnmarshal struct { Unmarshalers request.HandlerList } // UnmarshalPayload unmarshals the io.Reader payload into the SDK shape using // the Unmarshalers HandlerList provided. Returns an error if unable // unmarshaling fails. func (h HandlerPayloadUnmarshal) UnmarshalPayload(r io.Reader, v interface{}) error { req := &request.Request{ HTTPRequest: &http.Request{}, HTTPResponse: &http.Response{ StatusCode: 200, Header: http.Header{}, Body: ioutil.NopCloser(r), }, Data: v, } h.Unmarshalers.Run(req) return req.Error } // PayloadMarshaler provides the interface for marshaling a SDK shape into and // io.Writer. type PayloadMarshaler interface { MarshalPayload(io.Writer, interface{}) error } // HandlerPayloadMarshal implements the PayloadMarshaler from a HandlerList. // This provides support for marshaling a SDK shape into an io.Writer without // needing a SDK request first. type HandlerPayloadMarshal struct { Marshalers request.HandlerList } // MarshalPayload marshals the SDK shape into the io.Writer using the // Marshalers HandlerList provided. Returns an error if unable if marshal // fails. func (h HandlerPayloadMarshal) MarshalPayload(w io.Writer, v interface{}) error { req := request.New( aws.Config{}, metadata.ClientInfo{}, request.Handlers{}, nil, &request.Operation{HTTPMethod: "PUT"}, v, nil, ) h.Marshalers.Run(req) if req.Error != nil { return req.Error } io.Copy(w, req.GetBody()) return nil }	2.02 KB	2025-05-25 12:27
📄 protocol.go package protocol import ( "fmt" "strings" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" ) // RequireHTTPMinProtocol request handler is used to enforce that // the target endpoint supports the given major and minor HTTP protocol version. type RequireHTTPMinProtocol struct { Major, Minor int } // Handler will mark the request.Request with an error if the // target endpoint did not connect with the required HTTP protocol // major and minor version. func (p RequireHTTPMinProtocol) Handler(r request.Request) { if r.Error != nil \|\| r.HTTPResponse == nil { return } if !strings.HasPrefix(r.HTTPResponse.Proto, "HTTP") { r.Error = newMinHTTPProtoError(p.Major, p.Minor, r) } if r.HTTPResponse.ProtoMajor < p.Major \|\| r.HTTPResponse.ProtoMinor < p.Minor { r.Error = newMinHTTPProtoError(p.Major, p.Minor, r) } } // ErrCodeMinimumHTTPProtocolError error code is returned when the target endpoint // did not match the required HTTP major and minor protocol version. const ErrCodeMinimumHTTPProtocolError = "MinimumHTTPProtocolError" func newMinHTTPProtoError(major, minor int, r request.Request) error { return awserr.NewRequestFailure( awserr.New("MinimumHTTPProtocolError", fmt.Sprintf( "operation requires minimum HTTP protocol of HTTP/%d.%d, but was %s", major, minor, r.HTTPResponse.Proto, ), nil, ), r.HTTPResponse.StatusCode, r.RequestID, ) }	1.4 KB	2025-05-25 12:27
📄 protocol_go1.7_test.go //go:build go1.7 // +build go1.7 package protocol import ( "net/http" "strings" "testing" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" ) func TestRequireHTTPMinProtocol(t testing.T) { cases := map[string]struct { Major, Minor int Response http.Response Err string }{ "HTTP/2.0": { Major: 2, Response: &http.Response{ StatusCode: 200, Proto: "HTTP/2.0", ProtoMajor: 2, ProtoMinor: 0, }, }, "HTTP/1.1": { Major: 2, Response: &http.Response{ StatusCode: 200, Proto: "HTTP/1.1", ProtoMajor: 1, ProtoMinor: 1, }, Err: "operation requires minimum HTTP protocol", }, } for name, c := range cases { t.Run(name, func(t *testing.T) { req := &request.Request{ HTTPResponse: c.Response, } RequireHTTPMinProtocol{Major: c.Major, Minor: c.Minor}.Handler(req) if len(c.Err) != 0 { if req.Error == nil { t.Fatalf("expect error") } if e, a := c.Err, req.Error.Error(); !strings.Contains(a, e) { t.Errorf("expect %q error, got %q", e, a) } aerr, ok := req.Error.(awserr.RequestFailure) if !ok { t.Fatalf("expect RequestFailure, got %T", req.Error) } if e, a := ErrCodeMinimumHTTPProtocolError, aerr.Code(); e != a { t.Errorf("expect %v code, got %v", e, a) } if e, a := c.Response.StatusCode, aerr.StatusCode(); e != a { t.Errorf("expect %v status code, got %v", e, a) } } else { if err := req.Error; err != nil { t.Fatalf("expect no failure, got %v", err) } } }) } }	1.56 KB	2025-05-25 12:27
📄 protocol_test.go package protocol_test import ( "net/http" "net/url" "testing" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/awstesting" "github.com/aws/aws-sdk-go/private/protocol" "github.com/aws/aws-sdk-go/private/protocol/ec2query" "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" "github.com/aws/aws-sdk-go/private/protocol/query" "github.com/aws/aws-sdk-go/private/protocol/rest" "github.com/aws/aws-sdk-go/private/protocol/restjson" "github.com/aws/aws-sdk-go/private/protocol/restxml" ) func xmlData(set bool, b []byte, size, delta int) { const openingTags = "<B><A>" const closingTags = "</A></B>" if !set { copy(b, []byte(openingTags)) } if size == 0 { copy(b[delta-len(closingTags):], []byte(closingTags)) } } func jsonData(set bool, b []byte, size, delta int) { if !set { copy(b, []byte("{\"A\": \"")) } if size == 0 { copy(b[delta-len("\"}"):], []byte("\"}")) } } func buildNewRequest(data interface{}) request.Request { v := url.Values{} v.Set("test", "TEST") v.Add("test1", "TEST1") req := &request.Request{ HTTPRequest: &http.Request{ Header: make(http.Header), Body: &awstesting.ReadCloser{Size: 2048}, URL: &url.URL{ RawQuery: v.Encode(), }, }, Params: &struct { LocationName string `locationName:"test"` }{ "Test", }, ClientInfo: metadata.ClientInfo{ ServiceName: "test", TargetPrefix: "test", JSONVersion: "test", APIVersion: "test", Endpoint: "test", SigningName: "test", SigningRegion: "test", }, Operation: &request.Operation{ Name: "test", }, } req.HTTPResponse = &http.Response{ Body: &awstesting.ReadCloser{Size: 2048}, Header: http.Header{ "X-Amzn-Requestid": []string{"1"}, }, StatusCode: http.StatusOK, } if data == nil { data = &struct { _ struct{} `type:"structure"` LocationName string `locationName:"testName"` Location string `location:"statusCode"` A string `type:"string"` }{} } req.Data = data return req } type expected struct { dataType int closed bool size int errExists bool } const ( jsonType = iota xmlType ) func checkForLeak(data interface{}, build, fn func(request.Request), t testing.T, result expected) { req := buildNewRequest(data) reader := req.HTTPResponse.Body.(awstesting.ReadCloser) switch result.dataType { case jsonType: reader.FillData = jsonData case xmlType: reader.FillData = xmlData } build(req) fn(req) if result.errExists { if err := req.Error; err == nil { t.Errorf("expect error") } } else { if err := req.Error; err != nil { t.Errorf("expect nil, %v", err) } } if e, a := reader.Closed, result.closed; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := reader.Size, result.size; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestJSONRpc(t testing.T) { checkForLeak(nil, jsonrpc.Build, jsonrpc.Unmarshal, t, expected{jsonType, true, 0, false}) checkForLeak(nil, jsonrpc.Build, jsonrpc.UnmarshalMeta, t, expected{jsonType, false, 2048, false}) checkForLeak(nil, jsonrpc.Build, jsonrpc.UnmarshalError, t, expected{jsonType, true, 0, true}) } func TestQuery(t testing.T) { checkForLeak(nil, query.Build, query.Unmarshal, t, expected{jsonType, true, 0, false}) checkForLeak(nil, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false}) checkForLeak(nil, query.Build, query.UnmarshalError, t, expected{jsonType, true, 0, true}) } func TestRest(t testing.T) { // case 1: Payload io.ReadSeeker checkForLeak(nil, rest.Build, rest.Unmarshal, t, expected{jsonType, false, 2048, false}) checkForLeak(nil, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false}) // case 2: Payload string // should close the body dataStr := struct { _ struct{} `type:"structure" payload:"Payload"` LocationName string `locationName:"testName"` Location string `location:"statusCode"` A string `type:"string"` Payload string `locationName:"payload" type:"blob" required:"true"` }{} checkForLeak(&dataStr, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, false}) checkForLeak(&dataStr, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false}) // case 3: Payload []byte // should close the body dataBytes := struct { _ struct{} `type:"structure" payload:"Payload"` LocationName string `locationName:"testName"` Location string `location:"statusCode"` A string `type:"string"` Payload []byte `locationName:"payload" type:"blob" required:"true"` }{} checkForLeak(&dataBytes, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, false}) checkForLeak(&dataBytes, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false}) // case 4: Payload unsupported type // should close the body dataUnsupported := struct { _ struct{} `type:"structure" payload:"Payload"` LocationName string `locationName:"testName"` Location string `location:"statusCode"` A string `type:"string"` Payload string `locationName:"payload" type:"blob" required:"true"` }{} checkForLeak(&dataUnsupported, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, true}) checkForLeak(&dataUnsupported, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false}) } func TestRestJSON(t testing.T) { checkForLeak(nil, restjson.Build, restjson.Unmarshal, t, expected{jsonType, true, 0, false}) checkForLeak(nil, restjson.Build, restjson.UnmarshalMeta, t, expected{jsonType, false, 2048, false}) checkForLeak(nil, restjson.Build, restjson.UnmarshalError, t, expected{jsonType, true, 0, true}) } func TestRestXML(t testing.T) { checkForLeak(nil, restxml.Build, restxml.Unmarshal, t, expected{xmlType, true, 0, false}) checkForLeak(nil, restxml.Build, restxml.UnmarshalMeta, t, expected{xmlType, false, 2048, false}) checkForLeak(nil, restxml.Build, restxml.UnmarshalError, t, expected{xmlType, true, 0, true}) } func TestXML(t testing.T) { checkForLeak(nil, ec2query.Build, ec2query.Unmarshal, t, expected{jsonType, true, 0, false}) checkForLeak(nil, ec2query.Build, ec2query.UnmarshalMeta, t, expected{jsonType, false, 2048, false}) checkForLeak(nil, ec2query.Build, ec2query.UnmarshalError, t, expected{jsonType, true, 0, true}) } func TestProtocol(t *testing.T) { checkForLeak(nil, restxml.Build, protocol.UnmarshalDiscardBody, t, expected{xmlType, true, 0, false}) }	6.44 KB	2025-05-25 12:27
📁 query	-	2025-05-25 12:27
📁 rest	-	2025-05-25 12:27
📁 restjson	-	2025-05-25 12:27
📁 restxml	-	2025-05-25 12:27
📄 timestamp.go package protocol import ( "bytes" "fmt" "math" "strconv" "time" "github.com/aws/aws-sdk-go/internal/sdkmath" ) // Names of time formats supported by the SDK const ( RFC822TimeFormatName = "rfc822" ISO8601TimeFormatName = "iso8601" UnixTimeFormatName = "unixTimestamp" ) // Time formats supported by the SDK // Output time is intended to not contain decimals const ( // RFC 7231#section-7.1.1.1 timetamp format. e.g Tue, 29 Apr 2014 18:30:38 GMT RFC822TimeFormat = "Mon, 2 Jan 2006 15:04:05 GMT" rfc822TimeFormatSingleDigitDay = "Mon, _2 Jan 2006 15:04:05 GMT" rfc822TimeFormatSingleDigitDayTwoDigitYear = "Mon, _2 Jan 06 15:04:05 GMT" // This format is used for output time without seconds precision RFC822OutputTimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT" // RFC3339 a subset of the ISO8601 timestamp format. e.g 2014-04-29T18:30:38Z ISO8601TimeFormat = "2006-01-02T15:04:05.999999999Z" iso8601TimeFormatNoZ = "2006-01-02T15:04:05.999999999" // This format is used for output time with fractional second precision up to milliseconds ISO8601OutputTimeFormat = "2006-01-02T15:04:05.999999999Z" ) // IsKnownTimestampFormat returns if the timestamp format name // is know to the SDK's protocols. func IsKnownTimestampFormat(name string) bool { switch name { case RFC822TimeFormatName: fallthrough case ISO8601TimeFormatName: fallthrough case UnixTimeFormatName: return true default: return false } } // FormatTime returns a string value of the time. func FormatTime(name string, t time.Time) string { t = t.UTC().Truncate(time.Millisecond) switch name { case RFC822TimeFormatName: return t.Format(RFC822OutputTimeFormat) case ISO8601TimeFormatName: return t.Format(ISO8601OutputTimeFormat) case UnixTimeFormatName: ms := t.UnixNano() / int64(time.Millisecond) return strconv.FormatFloat(float64(ms)/1e3, 'f', -1, 64) default: panic("unknown timestamp format name, " + name) } } // ParseTime attempts to parse the time given the format. Returns // the time if it was able to be parsed, and fails otherwise. func ParseTime(formatName, value string) (time.Time, error) { switch formatName { case RFC822TimeFormatName: // Smithy HTTPDate format return tryParse(value, RFC822TimeFormat, rfc822TimeFormatSingleDigitDay, rfc822TimeFormatSingleDigitDayTwoDigitYear, time.RFC850, time.ANSIC, ) case ISO8601TimeFormatName: // Smithy DateTime format return tryParse(value, ISO8601TimeFormat, iso8601TimeFormatNoZ, time.RFC3339Nano, time.RFC3339, ) case UnixTimeFormatName: v, err := strconv.ParseFloat(value, 64) _, dec := math.Modf(v) dec = sdkmath.Round(dec1e3) / 1e3 //Rounds 0.1229999 to 0.123 if err != nil { return time.Time{}, err } return time.Unix(int64(v), int64(dec(1e9))), nil default: panic("unknown timestamp format name, " + formatName) } } func tryParse(v string, formats ...string) (time.Time, error) { var errs parseErrors for _, f := range formats { t, err := time.Parse(f, v) if err != nil { errs = append(errs, parseError{ Format: f, Err: err, }) continue } return t, nil } return time.Time{}, fmt.Errorf("unable to parse time string, %v", errs) } type parseErrors []parseError func (es parseErrors) Error() string { var s bytes.Buffer for _, e := range es { fmt.Fprintf(&s, "\n * %q: %v", e.Format, e.Err) } return "parse errors:" + s.String() } type parseError struct { Format string Err error }	3.44 KB	2025-05-25 12:27
📄 timestamp_test.go //go:build go1.7 // +build go1.7 package protocol import ( "testing" "time" ) func TestFormatTime(t testing.T) { cases := map[string]struct { formatName string expectedOutput string input time.Time }{ "UnixTest1": { formatName: UnixTimeFormatName, expectedOutput: "946845296", input: time.Date(2000, time.January, 2, 20, 34, 56, 0, time.UTC), }, "UnixTest2": { formatName: UnixTimeFormatName, expectedOutput: "946845296.123", input: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC), }, "ISO8601Test1": { formatName: ISO8601TimeFormatName, expectedOutput: "2000-01-02T20:34:56Z", input: time.Date(2000, time.January, 2, 20, 34, 56, 0, time.UTC), }, "RFC822Test1": { formatName: RFC822TimeFormatName, expectedOutput: "Sun, 02 Jan 2000 20:34:56 GMT", input: time.Date(2000, time.January, 2, 20, 34, 56, 0, time.UTC), }, "ISO8601Test2": { formatName: ISO8601TimeFormatName, expectedOutput: "2000-01-02T20:34:56.123Z", input: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC), }, "ISO8601Test3": { formatName: ISO8601TimeFormatName, expectedOutput: "2000-01-02T20:34:56.123Z", input: time.Date(2000, time.January, 2, 20, 34, 56, .123456e9, time.UTC), }, } for name, c := range cases { t.Run(name, func(t testing.T) { if e, a := c.expectedOutput, FormatTime(c.formatName, c.input); e != a { t.Errorf("expected %s, got %s for %s format ", e, a, c.formatName) } }) } } func TestParseTime(t testing.T) { //input and output times are considered equal if they are equal until three decimal places cases := map[string]struct { formatName, input string expectedOutput time.Time }{ "UnixTestExponent": { formatName: UnixTimeFormatName, input: "1.583858715232899e9", expectedOutput: time.Date(2020, time.March, 10, 16, 45, 15, .233e9, time.UTC), }, "UnixTest1": { formatName: UnixTimeFormatName, input: "946845296.123", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC), }, "UnixTest2": { formatName: UnixTimeFormatName, input: "946845296.12344", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC), }, "UnixTest3": { formatName: UnixTimeFormatName, input: "946845296.1229999", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC), }, "ISO8601Test milliseconds": { formatName: ISO8601TimeFormatName, input: "2000-01-02T20:34:56.123Z", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC), }, "ISO8601Test milliseconds, no Z": { formatName: ISO8601TimeFormatName, input: "2000-01-02T20:34:56.123", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC), }, "ISO8601Test nanoseconds": { formatName: ISO8601TimeFormatName, input: "2000-01-02T20:34:56.123456789Z", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123456789e9, time.UTC), }, "ISO8601Test millisecond utc offset": { formatName: ISO8601TimeFormatName, input: "2000-01-02T20:34:56.123-07:00", expectedOutput: time.Date(2000, time.January, 3, 3, 34, 56, .123e9, time.UTC), }, "ISO8601Test millisecond positive utc offset": { formatName: ISO8601TimeFormatName, input: "2000-01-02T20:34:56.123+07:00", expectedOutput: time.Date(2000, time.January, 2, 13, 34, 56, .123e9, time.UTC), }, "ISO8601Test nanosecond utc offset": { formatName: ISO8601TimeFormatName, input: "2000-01-02T20:34:56.123456789-07:00", expectedOutput: time.Date(2000, time.January, 3, 3, 34, 56, .123456789e9, time.UTC), }, "RFC822Test single digit day": { formatName: RFC822TimeFormatName, input: "Sun, 2 Jan 2000 20:34:56 GMT", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, 0, time.UTC), }, "RFC822Test two digit day": { formatName: RFC822TimeFormatName, input: "Sun, 02 Jan 2000 20:34:56 GMT", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, 0, time.UTC), }, "RFC822Test two digit day year": { formatName: RFC822TimeFormatName, input: "Sun, 2 Jan 00 20:34:56 GMT", expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, 0, time.UTC), }, } for name, c := range cases { t.Run(name, func(t testing.T) { timeVal, err := ParseTime(c.formatName, c.input) if err != nil { t.Errorf("expect no error, got %v", err) } if e, a := c.expectedOutput, timeVal.UTC(); !e.Equal(a) { t.Errorf("expect %v time, got %v", e, a) } }) } }	4.71 KB	2025-05-25 12:27
📄 unmarshal.go package protocol import ( "io" "io/ioutil" "github.com/aws/aws-sdk-go/aws/request" ) // UnmarshalDiscardBodyHandler is a named request handler to empty and close a response's body var UnmarshalDiscardBodyHandler = request.NamedHandler{Name: "awssdk.shared.UnmarshalDiscardBody", Fn: UnmarshalDiscardBody} // UnmarshalDiscardBody is a request handler to empty a response's body and closing it. func UnmarshalDiscardBody(r *request.Request) { if r.HTTPResponse == nil \|\| r.HTTPResponse.Body == nil { return } io.Copy(ioutil.Discard, r.HTTPResponse.Body) r.HTTPResponse.Body.Close() } // ResponseMetadata provides the SDK response metadata attributes. type ResponseMetadata struct { StatusCode int RequestID string }	732 B	2025-05-25 12:27
📄 unmarshal_error.go package protocol import ( "net/http" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" ) // UnmarshalErrorHandler provides unmarshaling errors API response errors for // both typed and untyped errors. type UnmarshalErrorHandler struct { unmarshaler ErrorUnmarshaler } // ErrorUnmarshaler is an abstract interface for concrete implementations to // unmarshal protocol specific response errors. type ErrorUnmarshaler interface { UnmarshalError(http.Response, ResponseMetadata) (error, error) } // NewUnmarshalErrorHandler returns an UnmarshalErrorHandler // initialized for the set of exception names to the error unmarshalers func NewUnmarshalErrorHandler(unmarshaler ErrorUnmarshaler) UnmarshalErrorHandler { return &UnmarshalErrorHandler{ unmarshaler: unmarshaler, } } // UnmarshalErrorHandlerName is the name of the named handler. const UnmarshalErrorHandlerName = "awssdk.protocol.UnmarshalError" // NamedHandler returns a NamedHandler for the unmarshaler using the set of // errors the unmarshaler was initialized for. func (u UnmarshalErrorHandler) NamedHandler() request.NamedHandler { return request.NamedHandler{ Name: UnmarshalErrorHandlerName, Fn: u.UnmarshalError, } } // UnmarshalError will attempt to unmarshal the API response's error message // into either a generic SDK error type, or a typed error corresponding to the // errors exception name. func (u UnmarshalErrorHandler) UnmarshalError(r *request.Request) { defer r.HTTPResponse.Body.Close() respMeta := ResponseMetadata{ StatusCode: r.HTTPResponse.StatusCode, RequestID: r.RequestID, } v, err := u.unmarshaler.UnmarshalError(r.HTTPResponse, respMeta) if err != nil { r.Error = awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "failed to unmarshal response error", err), respMeta.StatusCode, respMeta.RequestID, ) return } r.Error = v }	1.87 KB	2025-05-25 12:27
📄 unmarshal_test.go package protocol_test import ( "io/ioutil" "net/http" "strings" "testing" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/private/protocol" "github.com/aws/aws-sdk-go/private/protocol/ec2query" "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" "github.com/aws/aws-sdk-go/private/protocol/query" "github.com/aws/aws-sdk-go/private/protocol/restjson" "github.com/aws/aws-sdk-go/private/protocol/restxml" ) type mockCloser struct { strings.Reader Closed bool } func (m mockCloser) Close() error { m.Closed = true return nil } func TestUnmarshalDrainBody(t testing.T) { b := &mockCloser{Reader: strings.NewReader("example body")} r := &request.Request{HTTPResponse: &http.Response{ Body: b, }} protocol.UnmarshalDiscardBody(r) if err := r.Error; err != nil { t.Errorf("expect nil, %v", err) } if e, a := 0, b.Len(); e != a { t.Errorf("expect %v, got %v", e, a) } if !b.Closed { t.Errorf("expect true") } } func TestUnmarshalDrainBodyNoBody(t testing.T) { r := &request.Request{HTTPResponse: &http.Response{}} protocol.UnmarshalDiscardBody(r) if err := r.Error; err != nil { t.Errorf("expect nil, %v", err) } } func TestUnmarshalSeriaizationError(t testing.T) { type testOutput struct { _ struct{} } cases := []struct { name string r request.Request unmarshalFn func(request.Request) expectedError awserr.RequestFailure }{ { name: "jsonrpc", r: request.Request{ Data: &testOutput{}, HTTPResponse: &http.Response{ StatusCode: 502, Body: ioutil.NopCloser(strings.NewReader("invalid json")), }, }, unmarshalFn: jsonrpc.Unmarshal, expectedError: awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "", nil), 502, "", ), }, { name: "ec2query", r: request.Request{ Data: &testOutput{}, HTTPResponse: &http.Response{ StatusCode: 111, Body: ioutil.NopCloser(strings.NewReader("<<>>>>>>")), }, }, unmarshalFn: ec2query.Unmarshal, expectedError: awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "", nil), 111, "", ), }, { name: "query", r: request.Request{ Operation: &request.Operation{ Name: "Foo", }, Data: &testOutput{}, HTTPResponse: &http.Response{ StatusCode: 1, Body: ioutil.NopCloser(strings.NewReader("<<>>>>>>")), }, }, unmarshalFn: query.Unmarshal, expectedError: awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "", nil), 1, "", ), }, { name: "restjson", r: request.Request{ Data: &testOutput{}, HTTPResponse: &http.Response{ StatusCode: 123, Body: ioutil.NopCloser(strings.NewReader("invalid json")), }, }, unmarshalFn: restjson.Unmarshal, expectedError: awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "", nil), 123, "", ), }, { name: "restxml", r: request.Request{ Data: &testOutput{}, HTTPResponse: &http.Response{ StatusCode: 456, Body: ioutil.NopCloser(strings.NewReader("<<>>>>>>")), }, }, unmarshalFn: restxml.Unmarshal, expectedError: awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "", nil), 456, "", ), }, } for _, c := range cases { c.unmarshalFn(&c.r) rfErr, ok := c.r.Error.(awserr.RequestFailure) if !ok { t.Errorf("%s: expected awserr.RequestFailure, but received %T", c.name, c.r.Error) } if e, a := c.expectedError.StatusCode(), rfErr.StatusCode(); e != a { t.Errorf("%s: expected %v, but received %v", c.name, e, a) } } }	3.64 KB	2025-05-25 12:27
📁 xml	-	2025-05-25 12:27

Edit File:

Terminal