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
📄 client.go package client import ( "fmt" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/request" ) // A Config provides configuration to a service client instance. type Config struct { Config aws.Config Handlers request.Handlers PartitionID string Endpoint string SigningRegion string SigningName string ResolvedRegion string // States that the signing name did not come from a modeled source but // was derived based on other data. Used by service client constructors // to determine if the signin name can be overridden based on metadata the // service has. SigningNameDerived bool } // ConfigProvider provides a generic way for a service client to receive // the ClientConfig without circular dependencies. type ConfigProvider interface { ClientConfig(serviceName string, cfgs ...aws.Config) Config } // ConfigNoResolveEndpointProvider same as ConfigProvider except it will not // resolve the endpoint automatically. The service client's endpoint must be // provided via the aws.Config.Endpoint field. type ConfigNoResolveEndpointProvider interface { ClientConfigNoResolveEndpoint(cfgs ...aws.Config) Config } // A Client implements the base client request and response handling // used by all service clients. type Client struct { request.Retryer metadata.ClientInfo Config aws.Config Handlers request.Handlers } // New will return a pointer to a new initialized service client. func New(cfg aws.Config, info metadata.ClientInfo, handlers request.Handlers, options ...func(Client)) Client { svc := &Client{ Config: cfg, ClientInfo: info, Handlers: handlers.Copy(), } switch retryer, ok := cfg.Retryer.(request.Retryer); { case ok: svc.Retryer = retryer case cfg.Retryer != nil && cfg.Logger != nil: s := fmt.Sprintf("WARNING: %T does not implement request.Retryer; using DefaultRetryer instead", cfg.Retryer) cfg.Logger.Log(s) fallthrough default: maxRetries := aws.IntValue(cfg.MaxRetries) if cfg.MaxRetries == nil \|\| maxRetries == aws.UseServiceDefaultRetries { maxRetries = DefaultRetryerMaxNumRetries } svc.Retryer = DefaultRetryer{NumMaxRetries: maxRetries} } svc.AddDebugHandlers() for _, option := range options { option(svc) } return svc } // NewRequest returns a new Request pointer for the service API // operation and parameters. func (c Client) NewRequest(operation request.Operation, params interface{}, data interface{}) request.Request { return request.New(c.Config, c.ClientInfo, c.Handlers, c.Retryer, operation, params, data) } // AddDebugHandlers injects debug logging handlers into the service to log request // debug information. func (c *Client) AddDebugHandlers() { c.Handlers.Send.PushFrontNamed(LogHTTPRequestHandler) c.Handlers.Send.PushBackNamed(LogHTTPResponseHandler) }	2.81 KB	2025-05-25 12:27
📄 client_test.go package client import ( "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/request" ) func pushBackTestHandler(name string, list request.HandlerList) bool { called := false (list).PushBackNamed(request.NamedHandler{ Name: name, Fn: func(r request.Request) { called = true }, }) return &called } func pushFrontTestHandler(name string, list request.HandlerList) bool { called := false (list).PushFrontNamed(request.NamedHandler{ Name: name, Fn: func(r request.Request) { called = true }, }) return &called } func TestNewClient_CopyHandlers(t testing.T) { handlers := request.Handlers{} firstCalled := pushBackTestHandler("first", &handlers.Send) secondCalled := pushBackTestHandler("second", &handlers.Send) var clientHandlerCalled bool c := New(aws.Config{}, metadata.ClientInfo{}, handlers, func(c Client) { clientHandlerCalled = pushFrontTestHandler("client handler", &c.Handlers.Send) }, ) if e, a := 2, handlers.Send.Len(); e != a { t.Errorf("expect %d original handlers, got %d", e, a) } if e, a := 5, c.Handlers.Send.Len(); e != a { t.Errorf("expect %d client handlers, got %d", e, a) } req := c.NewRequest(&request.Operation{}, struct{}{}, struct{}{}) handlers.Send.Run(req) if !firstCalled { t.Errorf("expect first handler to of been called") } firstCalled = false if !secondCalled { t.Errorf("expect second handler to of been called") } secondCalled = false if clientHandlerCalled { t.Errorf("expect client handler to not of been called, but was") } c.Handlers.Send.Run(req) if !firstCalled { t.Errorf("expect client's first handler to of been called") } if !secondCalled { t.Errorf("expect client's second handler to of been called") } if !*clientHandlerCalled { t.Errorf("expect client's client handler to of been called") } }	1.87 KB	2025-05-25 12:27
📄 default_retryer.go package client import ( "math" "strconv" "time" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/internal/sdkrand" ) // DefaultRetryer implements basic retry logic using exponential backoff for // most services. If you want to implement custom retry logic, you can implement the // request.Retryer interface. // type DefaultRetryer struct { // Num max Retries is the number of max retries that will be performed. // By default, this is zero. NumMaxRetries int // MinRetryDelay is the minimum retry delay after which retry will be performed. // If not set, the value is 0ns. MinRetryDelay time.Duration // MinThrottleRetryDelay is the minimum retry delay when throttled. // If not set, the value is 0ns. MinThrottleDelay time.Duration // MaxRetryDelay is the maximum retry delay before which retry must be performed. // If not set, the value is 0ns. MaxRetryDelay time.Duration // MaxThrottleDelay is the maximum retry delay when throttled. // If not set, the value is 0ns. MaxThrottleDelay time.Duration } const ( // DefaultRetryerMaxNumRetries sets maximum number of retries DefaultRetryerMaxNumRetries = 3 // DefaultRetryerMinRetryDelay sets minimum retry delay DefaultRetryerMinRetryDelay = 30 * time.Millisecond // DefaultRetryerMinThrottleDelay sets minimum delay when throttled DefaultRetryerMinThrottleDelay = 500 * time.Millisecond // DefaultRetryerMaxRetryDelay sets maximum retry delay DefaultRetryerMaxRetryDelay = 300 * time.Second // DefaultRetryerMaxThrottleDelay sets maximum delay when throttled DefaultRetryerMaxThrottleDelay = 300 * time.Second ) // MaxRetries returns the number of maximum returns the service will use to make // an individual API request. func (d DefaultRetryer) MaxRetries() int { return d.NumMaxRetries } // setRetryerDefaults sets the default values of the retryer if not set func (d DefaultRetryer) setRetryerDefaults() { if d.MinRetryDelay == 0 { d.MinRetryDelay = DefaultRetryerMinRetryDelay } if d.MaxRetryDelay == 0 { d.MaxRetryDelay = DefaultRetryerMaxRetryDelay } if d.MinThrottleDelay == 0 { d.MinThrottleDelay = DefaultRetryerMinThrottleDelay } if d.MaxThrottleDelay == 0 { d.MaxThrottleDelay = DefaultRetryerMaxThrottleDelay } } // RetryRules returns the delay duration before retrying this request again func (d DefaultRetryer) RetryRules(r request.Request) time.Duration { // if number of max retries is zero, no retries will be performed. if d.NumMaxRetries == 0 { return 0 } // Sets default value for retryer members d.setRetryerDefaults() // minDelay is the minimum retryer delay minDelay := d.MinRetryDelay var initialDelay time.Duration isThrottle := r.IsErrorThrottle() if isThrottle { if delay, ok := getRetryAfterDelay(r); ok { initialDelay = delay } minDelay = d.MinThrottleDelay } retryCount := r.RetryCount // maxDelay the maximum retryer delay maxDelay := d.MaxRetryDelay if isThrottle { maxDelay = d.MaxThrottleDelay } var delay time.Duration // Logic to cap the retry count based on the minDelay provided actualRetryCount := int(math.Log2(float64(minDelay))) + 1 if actualRetryCount < 63-retryCount { delay = time.Duration(1<<uint64(retryCount)) * getJitterDelay(minDelay) if delay > maxDelay { delay = getJitterDelay(maxDelay / 2) } } else { delay = getJitterDelay(maxDelay / 2) } return delay + initialDelay } // getJitterDelay returns a jittered delay for retry func getJitterDelay(duration time.Duration) time.Duration { return time.Duration(sdkrand.SeededRand.Int63n(int64(duration)) + int64(duration)) } // ShouldRetry returns true if the request should be retried. func (d DefaultRetryer) ShouldRetry(r request.Request) bool { // ShouldRetry returns false if number of max retries is 0. if d.NumMaxRetries == 0 { return false } // If one of the other handlers already set the retry state // we don't want to override it based on the service's state if r.Retryable != nil { return r.Retryable } return r.IsErrorRetryable() \|\| r.IsErrorThrottle() } // This will look in the Retry-After header, RFC 7231, for how long // it will wait before attempting another request func getRetryAfterDelay(r request.Request) (time.Duration, bool) { if !canUseRetryAfterHeader(r) { return 0, false } delayStr := r.HTTPResponse.Header.Get("Retry-After") if len(delayStr) == 0 { return 0, false } delay, err := strconv.Atoi(delayStr) if err != nil { return 0, false } return time.Duration(delay) time.Second, true } // Will look at the status code to see if the retry header pertains to // the status code. func canUseRetryAfterHeader(r *request.Request) bool { switch r.HTTPResponse.StatusCode { case 429: case 503: default: return false } return true }	4.69 KB	2025-05-25 12:27
📄 default_retryer_test.go package client import ( "net/http" "testing" "time" "github.com/aws/aws-sdk-go/aws/request" ) func TestRetryThrottleStatusCodes(t testing.T) { cases := []struct { expectThrottle bool expectRetry bool r request.Request }{ { false, false, request.Request{ HTTPResponse: &http.Response{StatusCode: 200}, }, }, { true, true, request.Request{ HTTPResponse: &http.Response{StatusCode: 429}, }, }, { true, true, request.Request{ HTTPResponse: &http.Response{StatusCode: 502}, }, }, { true, true, request.Request{ HTTPResponse: &http.Response{StatusCode: 503}, }, }, { true, true, request.Request{ HTTPResponse: &http.Response{StatusCode: 504}, }, }, { false, true, request.Request{ HTTPResponse: &http.Response{StatusCode: 500}, }, }, } d := DefaultRetryer{NumMaxRetries: 10} for i, c := range cases { throttle := c.r.IsErrorThrottle() retry := d.ShouldRetry(&c.r) if e, a := c.expectThrottle, throttle; e != a { t.Errorf("%d: expected %v, but received %v", i, e, a) } if e, a := c.expectRetry, retry; e != a { t.Errorf("%d: expected %v, but received %v", i, e, a) } } } func TestCanUseRetryAfter(t testing.T) { cases := []struct { r request.Request e bool }{ { request.Request{ HTTPResponse: &http.Response{StatusCode: 200}, }, false, }, { request.Request{ HTTPResponse: &http.Response{StatusCode: 500}, }, false, }, { request.Request{ HTTPResponse: &http.Response{StatusCode: 429}, }, true, }, { request.Request{ HTTPResponse: &http.Response{StatusCode: 503}, }, true, }, } for i, c := range cases { a := canUseRetryAfterHeader(&c.r) if c.e != a { t.Errorf("%d: expected %v, but received %v", i, c.e, a) } } } func TestGetRetryDelay(t testing.T) { cases := []struct { r request.Request e time.Duration equal bool ok bool }{ { request.Request{ HTTPResponse: &http.Response{StatusCode: 429, Header: http.Header{"Retry-After": []string{"3600"}}}, }, 3600 time.Second, true, true, }, { request.Request{ HTTPResponse: &http.Response{StatusCode: 503, Header: http.Header{"Retry-After": []string{"120"}}}, }, 120 * time.Second, true, true, }, { request.Request{ HTTPResponse: &http.Response{StatusCode: 503, Header: http.Header{"Retry-After": []string{"120"}}}, }, 1 * time.Second, false, true, }, { request.Request{ HTTPResponse: &http.Response{StatusCode: 503, Header: http.Header{"Retry-After": []string{""}}}, }, 0 * time.Second, true, false, }, } for i, c := range cases { a, ok := getRetryAfterDelay(&c.r) if c.ok != ok { t.Errorf("%d: expected %v, but received %v", i, c.ok, ok) } if (c.e != a) == c.equal { t.Errorf("%d: expected %v, but received %v", i, c.e, a) } } } func TestRetryDelay(t testing.T) { d := DefaultRetryer{NumMaxRetries: 100} r := request.Request{} for i := 0; i < 100; i++ { rTemp := r rTemp.HTTPResponse = &http.Response{StatusCode: 500, Header: http.Header{"Retry-After": []string{"299"}}} rTemp.RetryCount = i a := d.RetryRules(&rTemp) if a > 5time.Minute { t.Errorf("retry delay should never be greater than five minutes, received %s for retrycount %d", a, i) } } for i := 0; i < 100; i++ { rTemp := r rTemp.RetryCount = i rTemp.HTTPResponse = &http.Response{StatusCode: 503, Header: http.Header{"Retry-After": []string{""}}} a := d.RetryRules(&rTemp) if a > 5time.Minute { t.Errorf("retry delay should not be greater than five minutes, received %s for retrycount %d", a, i) } } rTemp := r rTemp.RetryCount = 1 rTemp.HTTPResponse = &http.Response{StatusCode: 503, Header: http.Header{"Retry-After": []string{"300"}}} a := d.RetryRules(&rTemp) if a < 5time.Minute { t.Errorf("retry delay should not be less than retry-after duration, received %s for retrycount %d", a, 1) } }	3.96 KB	2025-05-25 12:27
📄 logger.go package client import ( "bytes" "fmt" "io" "io/ioutil" "net/http/httputil" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/request" ) const logReqMsg = `DEBUG: Request %s/%s Details: ---[ REQUEST POST-SIGN ]----------------------------- %s -----------------------------------------------------` const logReqErrMsg = `DEBUG ERROR: Request %s/%s: ---[ REQUEST DUMP ERROR ]----------------------------- %s ------------------------------------------------------` type logWriter struct { // Logger is what we will use to log the payload of a response. Logger aws.Logger // buf stores the contents of what has been read buf bytes.Buffer } func (logger logWriter) Write(b []byte) (int, error) { return logger.buf.Write(b) } type teeReaderCloser struct { // io.Reader will be a tee reader that is used during logging. // This structure will read from a body and write the contents to a logger. io.Reader // Source is used just to close when we are done reading. Source io.ReadCloser } func (reader teeReaderCloser) Close() error { return reader.Source.Close() } // LogHTTPRequestHandler is a SDK request handler to log the HTTP request sent // to a service. Will include the HTTP request body if the LogLevel of the // request matches LogDebugWithHTTPBody. var LogHTTPRequestHandler = request.NamedHandler{ Name: "awssdk.client.LogRequest", Fn: logRequest, } func logRequest(r request.Request) { if !r.Config.LogLevel.AtLeast(aws.LogDebug) \|\| r.Config.Logger == nil { return } logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody) bodySeekable := aws.IsReaderSeekable(r.Body) b, err := httputil.DumpRequestOut(r.HTTPRequest, logBody) if err != nil { r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg, r.ClientInfo.ServiceName, r.Operation.Name, err)) return } if logBody { if !bodySeekable { r.SetReaderBody(aws.ReadSeekCloser(r.HTTPRequest.Body)) } // Reset the request body because dumpRequest will re-wrap the // r.HTTPRequest's Body as a NoOpCloser and will not be reset after // read by the HTTP client reader. if err := r.Error; err != nil { r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg, r.ClientInfo.ServiceName, r.Operation.Name, err)) return } } r.Config.Logger.Log(fmt.Sprintf(logReqMsg, r.ClientInfo.ServiceName, r.Operation.Name, string(b))) } // LogHTTPRequestHeaderHandler is a SDK request handler to log the HTTP request sent // to a service. Will only log the HTTP request's headers. The request payload // will not be read. var LogHTTPRequestHeaderHandler = request.NamedHandler{ Name: "awssdk.client.LogRequestHeader", Fn: logRequestHeader, } func logRequestHeader(r request.Request) { if !r.Config.LogLevel.AtLeast(aws.LogDebug) \|\| r.Config.Logger == nil { return } b, err := httputil.DumpRequestOut(r.HTTPRequest, false) if err != nil { r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg, r.ClientInfo.ServiceName, r.Operation.Name, err)) return } r.Config.Logger.Log(fmt.Sprintf(logReqMsg, r.ClientInfo.ServiceName, r.Operation.Name, string(b))) } const logRespMsg = `DEBUG: Response %s/%s Details: ---[ RESPONSE ]-------------------------------------- %s -----------------------------------------------------` const logRespErrMsg = `DEBUG ERROR: Response %s/%s: ---[ RESPONSE DUMP ERROR ]----------------------------- %s -----------------------------------------------------` // LogHTTPResponseHandler is a SDK request handler to log the HTTP response // received from a service. Will include the HTTP response body if the LogLevel // of the request matches LogDebugWithHTTPBody. var LogHTTPResponseHandler = request.NamedHandler{ Name: "awssdk.client.LogResponse", Fn: logResponse, } func logResponse(r request.Request) { if !r.Config.LogLevel.AtLeast(aws.LogDebug) \|\| r.Config.Logger == nil { return } lw := &logWriter{r.Config.Logger, bytes.NewBuffer(nil)} if r.HTTPResponse == nil { lw.Logger.Log(fmt.Sprintf(logRespErrMsg, r.ClientInfo.ServiceName, r.Operation.Name, "request's HTTPResponse is nil")) return } logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody) if logBody { r.HTTPResponse.Body = &teeReaderCloser{ Reader: io.TeeReader(r.HTTPResponse.Body, lw), Source: r.HTTPResponse.Body, } } handlerFn := func(req request.Request) { b, err := httputil.DumpResponse(req.HTTPResponse, false) if err != nil { lw.Logger.Log(fmt.Sprintf(logRespErrMsg, req.ClientInfo.ServiceName, req.Operation.Name, err)) return } lw.Logger.Log(fmt.Sprintf(logRespMsg, req.ClientInfo.ServiceName, req.Operation.Name, string(b))) if logBody { b, err := ioutil.ReadAll(lw.buf) if err != nil { lw.Logger.Log(fmt.Sprintf(logRespErrMsg, req.ClientInfo.ServiceName, req.Operation.Name, err)) return } lw.Logger.Log(string(b)) } } const handlerName = "awsdk.client.LogResponse.ResponseBody" r.Handlers.Unmarshal.SetBackNamed(request.NamedHandler{ Name: handlerName, Fn: handlerFn, }) r.Handlers.UnmarshalError.SetBackNamed(request.NamedHandler{ Name: handlerName, Fn: handlerFn, }) } // LogHTTPResponseHeaderHandler is a SDK request handler to log the HTTP // response received from a service. Will only log the HTTP response's headers. // The response payload will not be read. var LogHTTPResponseHeaderHandler = request.NamedHandler{ Name: "awssdk.client.LogResponseHeader", Fn: logResponseHeader, } func logResponseHeader(r request.Request) { if !r.Config.LogLevel.AtLeast(aws.LogDebug) \|\| r.Config.Logger == nil { return } b, err := httputil.DumpResponse(r.HTTPResponse, false) if err != nil { r.Config.Logger.Log(fmt.Sprintf(logRespErrMsg, r.ClientInfo.ServiceName, r.Operation.Name, err)) return } r.Config.Logger.Log(fmt.Sprintf(logRespMsg, r.ClientInfo.ServiceName, r.Operation.Name, string(b))) }	5.73 KB	2025-05-25 12:27
📄 logger_test.go package client import ( "bytes" "fmt" "io" "io/ioutil" "net/http" "reflect" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/corehandlers" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/request" ) type mockCloser struct { closed bool } func (closer mockCloser) Read(b []byte) (int, error) { return 0, io.EOF } func (closer mockCloser) Close() error { closer.closed = true return nil } func TestTeeReaderCloser(t testing.T) { expected := "FOO" buf := bytes.NewBuffer([]byte(expected)) lw := bytes.NewBuffer(nil) c := &mockCloser{} closer := teeReaderCloser{ io.TeeReader(buf, lw), c, } b := make([]byte, len(expected)) _, err := closer.Read(b) closer.Close() if expected != lw.String() { t.Errorf("Expected %q, but received %q", expected, lw.String()) } if err != nil { t.Errorf("Expected 'nil', but received %v", err) } if !c.closed { t.Error("Expected 'true', but received 'false'") } } func TestLogWriter(t testing.T) { expected := "FOO" lw := &logWriter{nil, bytes.NewBuffer(nil)} lw.Write([]byte(expected)) if expected != lw.buf.String() { t.Errorf("Expected %q, but received %q", expected, lw.buf.String()) } } func TestLogRequest(t testing.T) { cases := []struct { Body io.ReadSeeker ExpectBody []byte LogLevel aws.LogLevelType }{ { Body: aws.ReadSeekCloser(bytes.NewBuffer([]byte("body content"))), ExpectBody: []byte("body content"), }, { Body: aws.ReadSeekCloser(bytes.NewBuffer([]byte("body content"))), LogLevel: aws.LogDebugWithHTTPBody, ExpectBody: []byte("body content"), }, { Body: bytes.NewReader([]byte("body content")), ExpectBody: []byte("body content"), }, { Body: bytes.NewReader([]byte("body content")), LogLevel: aws.LogDebugWithHTTPBody, ExpectBody: []byte("body content"), }, } for i, c := range cases { logW := bytes.NewBuffer(nil) req := request.New( aws.Config{ Credentials: credentials.AnonymousCredentials, Logger: &bufLogger{w: logW}, LogLevel: aws.LogLevel(c.LogLevel), }, metadata.ClientInfo{ Endpoint: "https://mock-service.mock-region.amazonaws.com", }, testHandlers(), nil, &request.Operation{ Name: "APIName", HTTPMethod: "POST", HTTPPath: "/", }, struct{}{}, nil, ) req.SetReaderBody(c.Body) req.Build() logRequest(req) b, err := ioutil.ReadAll(req.HTTPRequest.Body) if err != nil { t.Fatalf("%d, expect to read SDK request Body", i) } if e, a := c.ExpectBody, b; !reflect.DeepEqual(e, a) { t.Errorf("%d, expect %v body, got %v", i, e, a) } } } func TestLogResponse(t testing.T) { cases := []struct { Body bytes.Buffer ExpectBody []byte ReadBody bool LogLevel aws.LogLevelType ExpectLog bool }{ { Body: bytes.NewBuffer([]byte("body content")), ExpectBody: []byte("body content"), }, { Body: bytes.NewBuffer([]byte("body content")), LogLevel: aws.LogDebug, ExpectLog: true, ExpectBody: []byte("body content"), }, { Body: bytes.NewBuffer([]byte("body content")), LogLevel: aws.LogDebugWithHTTPBody, ExpectLog: true, ReadBody: true, ExpectBody: []byte("body content"), }, } for i, c := range cases { var logW bytes.Buffer req := request.New( aws.Config{ Credentials: credentials.AnonymousCredentials, Logger: &bufLogger{w: &logW}, LogLevel: aws.LogLevel(c.LogLevel), }, metadata.ClientInfo{ Endpoint: "https://mock-service.mock-region.amazonaws.com", }, testHandlers(), nil, &request.Operation{ Name: "APIName", HTTPMethod: "POST", HTTPPath: "/", }, struct{}{}, nil, ) req.HTTPResponse = &http.Response{ StatusCode: 200, Status: "OK", Header: http.Header{ "ABC": []string{"123"}, }, Body: ioutil.NopCloser(c.Body), } logResponse(req) req.Handlers.Unmarshal.Run(req) if c.ReadBody { if e, a := len(c.ExpectBody), c.Body.Len(); e != a { t.Errorf("%d, expect original body not to of been read", i) } } if c.ExpectLog && logW.Len() == 0 { t.Errorf("%d, expect HTTP Response headers to be logged", i) } else if !c.ExpectLog && logW.Len() != 0 { t.Errorf("%d, expect no log, got,\n%v", i, logW.String()) } b, err := ioutil.ReadAll(req.HTTPResponse.Body) if err != nil { t.Fatalf("%d, expect to read SDK request Body", i) } if e, a := c.ExpectBody, b; !bytes.Equal(e, a) { t.Errorf("%d, expect %v body, got %v", i, e, a) } } } type bufLogger struct { w bytes.Buffer } func (l *bufLogger) Log(args ...interface{}) { fmt.Fprintln(l.w, args...) } func testHandlers() request.Handlers { var handlers request.Handlers handlers.Build.PushBackNamed(corehandlers.SDKVersionUserAgentHandler) return handlers }	4.84 KB	2025-05-25 12:27
📁 metadata	-	2025-05-25 12:27
📄 no_op_retryer.go package client import ( "time" "github.com/aws/aws-sdk-go/aws/request" ) // NoOpRetryer provides a retryer that performs no retries. // It should be used when we do not want retries to be performed. type NoOpRetryer struct{} // MaxRetries returns the number of maximum returns the service will use to make // an individual API; For NoOpRetryer the MaxRetries will always be zero. func (d NoOpRetryer) MaxRetries() int { return 0 } // ShouldRetry will always return false for NoOpRetryer, as it should never retry. func (d NoOpRetryer) ShouldRetry(_ request.Request) bool { return false } // RetryRules returns the delay duration before retrying this request again; // since NoOpRetryer does not retry, RetryRules always returns 0. func (d NoOpRetryer) RetryRules(_ request.Request) time.Duration { return 0 }	822 B	2025-05-25 12:27
📄 no_op_retryer_test.go package client import ( "net/http" "testing" "time" "github.com/aws/aws-sdk-go/aws/request" ) func TestNoOpRetryer(t *testing.T) { cases := []struct { r request.Request expectMaxRetries int expectRetryDelay time.Duration expectRetry bool }{ { r: request.Request{ HTTPResponse: &http.Response{StatusCode: 200}, }, expectMaxRetries: 0, expectRetryDelay: 0, expectRetry: false, }, } d := NoOpRetryer{} for i, c := range cases { maxRetries := d.MaxRetries() retry := d.ShouldRetry(&c.r) retryDelay := d.RetryRules(&c.r) if e, a := c.expectMaxRetries, maxRetries; e != a { t.Errorf("%d: expected %v, but received %v for number of max retries", i, e, a) } if e, a := c.expectRetry, retry; e != a { t.Errorf("%d: expected %v, but received %v for should retry", i, e, a) } if e, a := c.expectRetryDelay, retryDelay; e != a { t.Errorf("%d: expected %v, but received %v as retry delay", i, e, a) } } }	992 B	2025-05-25 12:27

Terminal