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
📄 awsinternal.go // DO NOT EDIT package corehandlers const isAwsInternal = ""	61 B	2025-05-25 12:27
📄 handlers.go package corehandlers import ( "bytes" "fmt" "io/ioutil" "net/http" "net/url" "regexp" "strconv" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/request" ) // Interface for matching types which also have a Len method. type lener interface { Len() int } // BuildContentLengthHandler builds the content length of a request based on the body, // or will use the HTTPRequest.Header's "Content-Length" if defined. If unable // to determine request body length and no "Content-Length" was specified it will panic. // // The Content-Length will only be added to the request if the length of the body // is greater than 0. If the body is empty or the current `Content-Length` // header is <= 0, the header will also be stripped. var BuildContentLengthHandler = request.NamedHandler{Name: "core.BuildContentLengthHandler", Fn: func(r request.Request) { var length int64 if slength := r.HTTPRequest.Header.Get("Content-Length"); slength != "" { length, _ = strconv.ParseInt(slength, 10, 64) } else { if r.Body != nil { var err error length, err = aws.SeekerLen(r.Body) if err != nil { r.Error = awserr.New(request.ErrCodeSerialization, "failed to get request body's length", err) return } } } if length > 0 { r.HTTPRequest.ContentLength = length r.HTTPRequest.Header.Set("Content-Length", fmt.Sprintf("%d", length)) } else { r.HTTPRequest.ContentLength = 0 r.HTTPRequest.Header.Del("Content-Length") } }} var reStatusCode = regexp.MustCompile(`^(\d{3})`) // ValidateReqSigHandler is a request handler to ensure that the request's // signature doesn't expire before it is sent. This can happen when a request // is built and signed significantly before it is sent. Or significant delays // occur when retrying requests that would cause the signature to expire. var ValidateReqSigHandler = request.NamedHandler{ Name: "core.ValidateReqSigHandler", Fn: func(r request.Request) { // Unsigned requests are not signed if r.Config.Credentials == credentials.AnonymousCredentials { return } signedTime := r.Time if !r.LastSignedAt.IsZero() { signedTime = r.LastSignedAt } // 5 minutes to allow for some clock skew/delays in transmission. // Would be improved with aws/aws-sdk-go#423 if signedTime.Add(5 * time.Minute).After(time.Now()) { return } fmt.Println("request expired, resigning") r.Sign() }, } // SendHandler is a request handler to send service request using HTTP client. var SendHandler = request.NamedHandler{ Name: "core.SendHandler", Fn: func(r request.Request) { sender := sendFollowRedirects if r.DisableFollowRedirects { sender = sendWithoutFollowRedirects } if request.NoBody == r.HTTPRequest.Body { // Strip off the request body if the NoBody reader was used as a // place holder for a request body. This prevents the SDK from // making requests with a request body when it would be invalid // to do so. // // Use a shallow copy of the http.Request to ensure the race condition // of transport on Body will not trigger reqOrig, reqCopy := r.HTTPRequest, r.HTTPRequest reqCopy.Body = nil r.HTTPRequest = &reqCopy defer func() { r.HTTPRequest = reqOrig }() } var err error r.HTTPResponse, err = sender(r) if err != nil { handleSendError(r, err) } }, } func sendFollowRedirects(r request.Request) (http.Response, error) { return r.Config.HTTPClient.Do(r.HTTPRequest) } func sendWithoutFollowRedirects(r request.Request) (http.Response, error) { transport := r.Config.HTTPClient.Transport if transport == nil { transport = http.DefaultTransport } return transport.RoundTrip(r.HTTPRequest) } func handleSendError(r request.Request, err error) { // Prevent leaking if an HTTPResponse was returned. Clean up // the body. if r.HTTPResponse != nil { r.HTTPResponse.Body.Close() } // Capture the case where url.Error is returned for error processing // response. e.g. 301 without location header comes back as string // error and r.HTTPResponse is nil. Other URL redirect errors will // comeback in a similar method. if e, ok := err.(url.Error); ok && e.Err != nil { if s := reStatusCode.FindStringSubmatch(e.Err.Error()); s != nil { code, _ := strconv.ParseInt(s[1], 10, 64) r.HTTPResponse = &http.Response{ StatusCode: int(code), Status: http.StatusText(int(code)), Body: ioutil.NopCloser(bytes.NewReader([]byte{})), } return } } if r.HTTPResponse == nil { // Add a dummy request response object to ensure the HTTPResponse // value is consistent. r.HTTPResponse = &http.Response{ StatusCode: int(0), Status: http.StatusText(int(0)), Body: ioutil.NopCloser(bytes.NewReader([]byte{})), } } // Catch all request errors, and let the default retrier determine // if the error is retryable. r.Error = awserr.New(request.ErrCodeRequestError, "send request failed", err) // Override the error with a context canceled error, if that was canceled. ctx := r.Context() select { case <-ctx.Done(): r.Error = awserr.New(request.CanceledErrorCode, "request context canceled", ctx.Err()) r.Retryable = aws.Bool(false) default: } } // ValidateResponseHandler is a request handler to validate service response. var ValidateResponseHandler = request.NamedHandler{Name: "core.ValidateResponseHandler", Fn: func(r request.Request) { if r.HTTPResponse.StatusCode == 0 \|\| r.HTTPResponse.StatusCode >= 300 { // this may be replaced by an UnmarshalError handler r.Error = awserr.New("UnknownError", "unknown error", r.Error) } }} // AfterRetryHandler performs final checks to determine if the request should // be retried and how long to delay. var AfterRetryHandler = request.NamedHandler{ Name: "core.AfterRetryHandler", Fn: func(r request.Request) { // 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 \|\| aws.BoolValue(r.Config.EnforceShouldRetryCheck) { r.Retryable = aws.Bool(r.ShouldRetry(r)) } if r.WillRetry() { r.RetryDelay = r.RetryRules(r) if sleepFn := r.Config.SleepDelay; sleepFn != nil { // Support SleepDelay for backwards compatibility and testing sleepFn(r.RetryDelay) } else if err := aws.SleepWithContext(r.Context(), r.RetryDelay); err != nil { r.Error = awserr.New(request.CanceledErrorCode, "request context canceled", err) r.Retryable = aws.Bool(false) return } // when the expired token exception occurs the credentials // need to be expired locally so that the next request to // get credentials will trigger a credentials refresh. if r.IsErrorExpired() { r.Config.Credentials.Expire() } r.RetryCount++ r.Error = nil } }} // ValidateEndpointHandler is a request handler to validate a request had the // appropriate Region and Endpoint set. Will set r.Error if the endpoint or // region is not valid. var ValidateEndpointHandler = request.NamedHandler{Name: "core.ValidateEndpointHandler", Fn: func(r *request.Request) { if r.ClientInfo.SigningRegion == "" && aws.StringValue(r.Config.Region) == "" { r.Error = aws.ErrMissingRegion } else if r.ClientInfo.Endpoint == "" { // Was any endpoint provided by the user, or one was derived by the // SDK's endpoint resolver? r.Error = aws.ErrMissingEndpoint } }}	7.31 KB	2025-05-25 12:27
📄 handlers_1_10_test.go //go:build go1.10 // +build go1.10 package corehandlers_test import ( "bytes" "io" "net/http" "net/http/httptest" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/awstesting/unit" "github.com/aws/aws-sdk-go/service/s3" ) func TestSendHandler_HEADNoBody(t testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { defer r.Body.Close() if e, a := "HEAD", r.Method; e != a { t.Errorf("expected %v method, got %v", e, a) } var buf bytes.Buffer io.Copy(&buf, r.Body) if n := buf.Len(); n != 0 { t.Errorf("expect empty body, got %d", n) } w.WriteHeader(http.StatusOK) })) defer server.Close() svc := s3.New(unit.Session, &aws.Config{ Endpoint: aws.String(server.URL), Credentials: credentials.AnonymousCredentials, S3ForcePathStyle: aws.Bool(true), DisableSSL: aws.Bool(true), }) req, _ := svc.HeadObjectRequest(&s3.HeadObjectInput{ Bucket: aws.String("bucketname"), Key: aws.String("keyname"), }) if e, a := request.NoBody, req.HTTPRequest.Body; e != a { t.Fatalf("expect %T request body, got %T", e, a) } if err := req.Send(); err != nil { t.Fatalf("expect no error, got %v", err) } if e, a := http.StatusOK, req.HTTPResponse.StatusCode; e != a { t.Errorf("expect %d status code, got %d", e, a) } }	1.41 KB	2025-05-25 12:27
📄 handlers_test.go package corehandlers_test import ( "bytes" "fmt" "io/ioutil" "net/http" "net/http/httptest" "net/url" "strings" "testing" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/client" "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" "github.com/aws/aws-sdk-go/awstesting" "github.com/aws/aws-sdk-go/awstesting/unit" "github.com/aws/aws-sdk-go/internal/sdktesting" "github.com/aws/aws-sdk-go/service/s3" ) func TestValidateEndpointHandler(t testing.T) { restoreEnvFn := sdktesting.StashEnv() defer restoreEnvFn() svc := awstesting.NewClient(aws.NewConfig().WithRegion("us-west-2")) svc.Handlers.Clear() svc.Handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler) req := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) err := req.Build() if err != nil { t.Errorf("expect no error, got %v", err) } } func TestValidateEndpointHandlerErrorRegion(t testing.T) { restoreEnvFn := sdktesting.StashEnv() defer restoreEnvFn() svc := awstesting.NewClient() svc.Handlers.Clear() svc.Handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler) req := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) err := req.Build() if err == nil { t.Errorf("expect error, got none") } if e, a := aws.ErrMissingRegion, err; e != a { t.Errorf("expect %v to be %v", e, a) } } type mockCredsProvider struct { expired bool retrieveCalled bool } func (m mockCredsProvider) Retrieve() (credentials.Value, error) { m.retrieveCalled = true return credentials.Value{ AccessKeyID: "AKID", SecretAccessKey: "SECRET", ProviderName: "mockCredsProvider", }, nil } func (m mockCredsProvider) IsExpired() bool { return m.expired } func TestAfterRetryRefreshCreds(t testing.T) { restoreEnvFn := sdktesting.StashEnv() defer restoreEnvFn() credProvider := &mockCredsProvider{} sess := unit.Session.Copy(&aws.Config{ Credentials: credentials.NewCredentials(credProvider), MaxRetries: aws.Int(2), }) clientInfo := metadata.ClientInfo{ Endpoint: "http://endpoint", SigningName: "", } svc := client.New(sess.Config, clientInfo, sess.Handlers) svc.Handlers.Sign.PushBack(func(r request.Request) { if !svc.Config.Credentials.IsExpired() { t.Errorf("expect credentials of of been expired before request attempt") } _, err := svc.Config.Credentials.Get() r.Error = err }) var respID int resps := []struct { Resp http.Response Err error }{ { Resp: &http.Response{ StatusCode: 403, Header: http.Header{}, Body: ioutil.NopCloser(bytes.NewBuffer([]byte{})), }, Err: awserr.New("ExpiredToken", "", nil), }, { Resp: &http.Response{ StatusCode: 403, Header: http.Header{}, Body: ioutil.NopCloser(bytes.NewBuffer([]byte{})), }, Err: awserr.New("ExpiredToken", "", nil), }, { Resp: &http.Response{ StatusCode: 200, Header: http.Header{}, Body: ioutil.NopCloser(bytes.NewBuffer([]byte{})), }, }, } svc.Handlers.Send.Clear() svc.Handlers.Send.PushBack(func(r request.Request) { r.HTTPResponse = resps[respID].Resp }) svc.Handlers.UnmarshalError.PushBack(func(r request.Request) { r.Error = resps[respID].Err }) svc.Handlers.CompleteAttempt.PushBack(func(r request.Request) { respID++ }) if !svc.Config.Credentials.IsExpired() { t.Fatalf("expect to start out expired") } if credProvider.retrieveCalled { t.Fatalf("expect retrieve not yet called") } req := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) if err := req.Send(); err != nil { t.Fatalf("expect no error, got %v", err) } if e, a := len(resps)-1, req.RetryCount; e != a { t.Errorf("expect %v retries, got %v", e, a) } if svc.Config.Credentials.IsExpired() { t.Errorf("expect credentials not to be expired") } if !credProvider.retrieveCalled { t.Errorf("expect retrieve to be called") } } func TestAfterRetryWithContextCanceled(t testing.T) { c := awstesting.NewClient() req := c.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) ctx := &awstesting.FakeContext{DoneCh: make(chan struct{})} req.SetContext(ctx) req.Error = fmt.Errorf("some error") req.Retryable = aws.Bool(true) req.HTTPResponse = &http.Response{ StatusCode: 500, } close(ctx.DoneCh) ctx.Error = fmt.Errorf("context canceled") corehandlers.AfterRetryHandler.Fn(req) if req.Error == nil { t.Fatalf("expect error but didn't receive one") } aerr := req.Error.(awserr.Error) if e, a := request.CanceledErrorCode, aerr.Code(); e != a { t.Errorf("expect %q, error code got %q", e, a) } } func TestAfterRetryWithContext(t testing.T) { c := awstesting.NewClient() req := c.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) ctx := &awstesting.FakeContext{DoneCh: make(chan struct{})} req.SetContext(ctx) req.Error = fmt.Errorf("some error") req.Retryable = aws.Bool(true) req.HTTPResponse = &http.Response{ StatusCode: 500, } corehandlers.AfterRetryHandler.Fn(req) if req.Error != nil { t.Fatalf("expect no error, got %v", req.Error) } if e, a := 1, req.RetryCount; e != a { t.Errorf("expect retry count to be %d, got %d", e, a) } } func TestSendWithContextCanceled(t testing.T) { c := awstesting.NewClient(&aws.Config{ SleepDelay: func(dur time.Duration) { t.Errorf("SleepDelay should not be called") }, }) req := c.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) ctx := &awstesting.FakeContext{DoneCh: make(chan struct{})} req.SetContext(ctx) req.Error = fmt.Errorf("some error") req.Retryable = aws.Bool(true) req.HTTPResponse = &http.Response{ StatusCode: 500, } close(ctx.DoneCh) ctx.Error = fmt.Errorf("context canceled") corehandlers.SendHandler.Fn(req) if req.Error == nil { t.Fatalf("expect error but didn't receive one") } aerr := req.Error.(awserr.Error) if e, a := request.CanceledErrorCode, aerr.Code(); e != a { t.Errorf("expect %q, error code got %q", e, a) } } type testSendHandlerTransport struct{} func (t testSendHandlerTransport) RoundTrip(r http.Request) (http.Response, error) { return nil, fmt.Errorf("mock error") } func TestSendHandlerError(t testing.T) { svc := awstesting.NewClient(&aws.Config{ HTTPClient: &http.Client{ Transport: &testSendHandlerTransport{}, }, }) svc.Handlers.Clear() svc.Handlers.Send.PushBackNamed(corehandlers.SendHandler) r := svc.NewRequest(&request.Operation{Name: "Operation"}, nil, nil) r.Send() if r.Error == nil { t.Errorf("expect error, got none") } if r.HTTPResponse == nil { t.Errorf("expect response, got none") } } func TestSendWithoutFollowRedirects(t testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { switch r.URL.Path { case "/original": w.Header().Set("Location", "/redirected") w.WriteHeader(301) case "/redirected": t.Fatalf("expect not to redirect, but was") } })) defer server.Close() svc := awstesting.NewClient(&aws.Config{ DisableSSL: aws.Bool(true), Endpoint: aws.String(server.URL), }) svc.Handlers.Clear() svc.Handlers.Send.PushBackNamed(corehandlers.SendHandler) r := svc.NewRequest(&request.Operation{ Name: "Operation", HTTPPath: "/original", }, nil, nil) r.DisableFollowRedirects = true err := r.Send() if err != nil { t.Errorf("expect no error, got %v", err) } if e, a := 301, r.HTTPResponse.StatusCode; e != a { t.Errorf("expect %d status code, got %d", e, a) } } func TestValidateReqSigHandler(t testing.T) { cases := []struct { Req request.Request Resign bool }{ { Req: &request.Request{ Config: aws.Config{Credentials: credentials.AnonymousCredentials}, Time: time.Now().Add(-15 * time.Minute), }, Resign: false, }, { Req: &request.Request{ Time: time.Now().Add(-15 * time.Minute), }, Resign: true, }, { Req: &request.Request{ Time: time.Now().Add(-1 * time.Minute), }, Resign: false, }, } for i, c := range cases { c.Req.HTTPRequest = &http.Request{URL: &url.URL{}} resigned := false c.Req.Handlers.Sign.PushBack(func(r request.Request) { resigned = true }) corehandlers.ValidateReqSigHandler.Fn(c.Req) if c.Req.Error != nil { t.Errorf("expect no error, got %v", c.Req.Error) } if e, a := c.Resign, resigned; e != a { t.Errorf("%d, expect %v to be %v", i, e, a) } } } func setupContentLengthTestServer(t testing.T, hasContentLength bool, contentLength int64) httptest.Server { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { _, ok := r.Header["Content-Length"] if e, a := hasContentLength, ok; e != a { t.Errorf("expect %v to be %v", e, a) } if hasContentLength { if e, a := contentLength, r.ContentLength; e != a { t.Errorf("expect %v to be %v", e, a) } } b, err := ioutil.ReadAll(r.Body) if err != nil { t.Errorf("expect no error, got %v", err) } r.Body.Close() authHeader := r.Header.Get("Authorization") if hasContentLength { if e, a := "content-length", authHeader; !strings.Contains(a, e) { t.Errorf("expect %v to be in %v", e, a) } } else { if e, a := "content-length", authHeader; strings.Contains(a, e) { t.Errorf("expect %v to not be in %v", e, a) } } if e, a := contentLength, int64(len(b)); e != a { t.Errorf("expect %v to be %v", e, a) } })) return server } func TestBuildContentLength_ZeroBody(t testing.T) { server := setupContentLengthTestServer(t, false, 0) defer server.Close() svc := s3.New(unit.Session, &aws.Config{ Endpoint: aws.String(server.URL), S3ForcePathStyle: aws.Bool(true), DisableSSL: aws.Bool(true), }) _, err := svc.GetObject(&s3.GetObjectInput{ Bucket: aws.String("bucketname"), Key: aws.String("keyname"), }) if err != nil { t.Errorf("expect no error, got %v", err) } } func TestBuildContentLength_NegativeBody(t testing.T) { server := setupContentLengthTestServer(t, false, 0) defer server.Close() svc := s3.New(unit.Session, &aws.Config{ Endpoint: aws.String(server.URL), S3ForcePathStyle: aws.Bool(true), DisableSSL: aws.Bool(true), }) req, _ := svc.GetObjectRequest(&s3.GetObjectInput{ Bucket: aws.String("bucketname"), Key: aws.String("keyname"), }) req.HTTPRequest.Header.Set("Content-Length", "-1") if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } } func TestBuildContentLength_WithBody(t *testing.T) { server := setupContentLengthTestServer(t, true, 1024) defer server.Close() svc := s3.New(unit.Session, &aws.Config{ Endpoint: aws.String(server.URL), S3ForcePathStyle: aws.Bool(true), DisableSSL: aws.Bool(true), }) _, err := svc.PutObject(&s3.PutObjectInput{ Bucket: aws.String("bucketname"), Key: aws.String("keyname"), Body: bytes.NewReader(make([]byte, 1024)), }) if err != nil { t.Errorf("expect no error, got %v", err) } }	10.93 KB	2025-05-25 12:27
📄 param_validator.go package corehandlers import "github.com/aws/aws-sdk-go/aws/request" // ValidateParametersHandler is a request handler to validate the input parameters. // Validating parameters only has meaning if done prior to the request being sent. var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) { if !r.ParamsFilled() { return } if v, ok := r.Params.(request.Validator); ok { if err := v.Validate(); err != nil { r.Error = err } } }}	512 B	2025-05-25 12:27
📄 param_validator_test.go package corehandlers_test import ( "fmt" "reflect" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/client" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/corehandlers" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/awstesting/unit" "github.com/aws/aws-sdk-go/service/kinesis" ) var testSvc = func() client.Client { s := &client.Client{ Config: aws.Config{}, ClientInfo: metadata.ClientInfo{ ServiceName: "mock-service", APIVersion: "2015-01-01", }, } return s }() type StructShape struct { _ struct{} `type:"structure"` RequiredList []ConditionalStructShape `required:"true"` RequiredMap map[string]ConditionalStructShape `required:"true"` RequiredBool bool `required:"true"` OptionalStruct ConditionalStructShape hiddenParameter string } func (s StructShape) Validate() error { invalidParams := request.ErrInvalidParams{Context: "StructShape"} if s.RequiredList == nil { invalidParams.Add(request.NewErrParamRequired("RequiredList")) } if s.RequiredMap == nil { invalidParams.Add(request.NewErrParamRequired("RequiredMap")) } if s.RequiredBool == nil { invalidParams.Add(request.NewErrParamRequired("RequiredBool")) } if s.RequiredList != nil { for i, v := range s.RequiredList { if v == nil { continue } if err := v.Validate(); err != nil { invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RequiredList", i), err.(request.ErrInvalidParams)) } } } if s.RequiredMap != nil { for i, v := range s.RequiredMap { if v == nil { continue } if err := v.Validate(); err != nil { invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RequiredMap", i), err.(request.ErrInvalidParams)) } } } if s.OptionalStruct != nil { if err := s.OptionalStruct.Validate(); err != nil { invalidParams.AddNested("OptionalStruct", err.(request.ErrInvalidParams)) } } if invalidParams.Len() > 0 { return invalidParams } return nil } type ConditionalStructShape struct { _ struct{} `type:"structure"` Name string `required:"true"` } func (s ConditionalStructShape) Validate() error { invalidParams := request.ErrInvalidParams{Context: "ConditionalStructShape"} if s.Name == nil { invalidParams.Add(request.NewErrParamRequired("Name")) } if invalidParams.Len() > 0 { return invalidParams } return nil } func TestNoErrors(t testing.T) { input := &StructShape{ RequiredList: []ConditionalStructShape{}, RequiredMap: map[string]ConditionalStructShape{ "key1": {Name: aws.String("Name")}, "key2": {Name: aws.String("Name")}, }, RequiredBool: aws.Bool(true), OptionalStruct: &ConditionalStructShape{Name: aws.String("Name")}, } req := testSvc.NewRequest(&request.Operation{}, input, nil) corehandlers.ValidateParametersHandler.Fn(req) if req.Error != nil { t.Fatalf("expect no error, got %v", req.Error) } } func TestMissingRequiredParameters(t testing.T) { input := &StructShape{} req := testSvc.NewRequest(&request.Operation{}, input, nil) corehandlers.ValidateParametersHandler.Fn(req) if req.Error == nil { t.Fatalf("expect error") } if e, a := "InvalidParameter", req.Error.(awserr.Error).Code(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "3 validation error(s) found.", req.Error.(awserr.Error).Message(); e != a { t.Errorf("expect %v, got %v", e, a) } errs := req.Error.(awserr.BatchedErrors).OrigErrs() if e, a := 3, len(errs); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "ParamRequiredError: missing required field, StructShape.RequiredList.", errs[0].Error(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "ParamRequiredError: missing required field, StructShape.RequiredMap.", errs[1].Error(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "ParamRequiredError: missing required field, StructShape.RequiredBool.", errs[2].Error(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "InvalidParameter: 3 validation error(s) found.\n- missing required field, StructShape.RequiredList.\n- missing required field, StructShape.RequiredMap.\n- missing required field, StructShape.RequiredBool.\n", req.Error.Error(); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestNestedMissingRequiredParameters(t testing.T) { input := &StructShape{ RequiredList: []ConditionalStructShape{{}}, RequiredMap: map[string]ConditionalStructShape{ "key1": {Name: aws.String("Name")}, "key2": {}, }, RequiredBool: aws.Bool(true), OptionalStruct: &ConditionalStructShape{}, } req := testSvc.NewRequest(&request.Operation{}, input, nil) corehandlers.ValidateParametersHandler.Fn(req) if req.Error == nil { t.Fatalf("expect error") } if e, a := "InvalidParameter", req.Error.(awserr.Error).Code(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "3 validation error(s) found.", req.Error.(awserr.Error).Message(); e != a { t.Errorf("expect %v, got %v", e, a) } errs := req.Error.(awserr.BatchedErrors).OrigErrs() if e, a := 3, len(errs); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "ParamRequiredError: missing required field, StructShape.RequiredList[0].Name.", errs[0].Error(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "ParamRequiredError: missing required field, StructShape.RequiredMap[key2].Name.", errs[1].Error(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "ParamRequiredError: missing required field, StructShape.OptionalStruct.Name.", errs[2].Error(); e != a { t.Errorf("expect %v, got %v", e, a) } } type testInput struct { StringField string `min:"5"` ListField []string `min:"3"` MapField map[string]string `min:"4"` } func (s testInput) Validate() error { invalidParams := request.ErrInvalidParams{Context: "testInput"} if s.StringField != nil && len(s.StringField) < 5 { invalidParams.Add(request.NewErrParamMinLen("StringField", 5)) } if s.ListField != nil && len(s.ListField) < 3 { invalidParams.Add(request.NewErrParamMinLen("ListField", 3)) } if s.MapField != nil && len(s.MapField) < 4 { invalidParams.Add(request.NewErrParamMinLen("MapField", 4)) } if invalidParams.Len() > 0 { return invalidParams } return nil } var testsFieldMin = []struct { err awserr.Error in testInput }{ { err: func() awserr.Error { invalidParams := request.ErrInvalidParams{Context: "testInput"} invalidParams.Add(request.NewErrParamMinLen("StringField", 5)) return invalidParams }(), in: testInput{StringField: aws.String("abcd")}, }, { err: func() awserr.Error { invalidParams := request.ErrInvalidParams{Context: "testInput"} invalidParams.Add(request.NewErrParamMinLen("StringField", 5)) invalidParams.Add(request.NewErrParamMinLen("ListField", 3)) return invalidParams }(), in: testInput{StringField: aws.String("abcd"), ListField: []string{"a", "b"}}, }, { err: func() awserr.Error { invalidParams := request.ErrInvalidParams{Context: "testInput"} invalidParams.Add(request.NewErrParamMinLen("StringField", 5)) invalidParams.Add(request.NewErrParamMinLen("ListField", 3)) invalidParams.Add(request.NewErrParamMinLen("MapField", 4)) return invalidParams }(), in: testInput{StringField: aws.String("abcd"), ListField: []string{"a", "b"}, MapField: map[string]string{"a": "a", "b": "b"}}, }, { err: nil, in: testInput{StringField: aws.String("abcde"), ListField: []string{"a", "b", "c"}, MapField: map[string]string{"a": "a", "b": "b", "c": "c", "d": "d"}}, }, } func TestValidateFieldMinParameter(t testing.T) { for i, c := range testsFieldMin { req := testSvc.NewRequest(&request.Operation{}, &c.in, nil) corehandlers.ValidateParametersHandler.Fn(req) if e, a := c.err, req.Error; !reflect.DeepEqual(e, a) { t.Errorf("%d, expect %v, got %v", i, e, a) } } } func BenchmarkValidateAny(b testing.B) { input := &kinesis.PutRecordsInput{ StreamName: aws.String("stream"), } for i := 0; i < 100; i++ { record := &kinesis.PutRecordsRequestEntry{ Data: make([]byte, 10000), PartitionKey: aws.String("partition"), } input.Records = append(input.Records, record) } req, _ := kinesis.New(unit.Session).PutRecordsRequest(input) b.ResetTimer() for i := 0; i < b.N; i++ { corehandlers.ValidateParametersHandler.Fn(req) if err := req.Error; err != nil { b.Fatalf("validation failed: %v", err) } } }	8.36 KB	2025-05-25 12:27
📄 user_agent.go package corehandlers import ( "os" "runtime" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/request" ) // SDKVersionUserAgentHandler is a request handler for adding the SDK Version // to the user agent. var SDKVersionUserAgentHandler = request.NamedHandler{ Name: "core.SDKVersionUserAgentHandler", Fn: request.MakeAddToUserAgentHandler(aws.SDKName, aws.SDKVersion, runtime.Version(), runtime.GOOS, runtime.GOARCH), } const execEnvVar = `AWS_EXECUTION_ENV` const execEnvUAKey = `exec-env` // AddHostExecEnvUserAgentHander is a request handler appending the SDK's // execution environment to the user agent. // // If the environment variable AWS_EXECUTION_ENV is set, its value will be // appended to the user agent string. var AddHostExecEnvUserAgentHander = request.NamedHandler{ Name: "core.AddHostExecEnvUserAgentHander", Fn: func(r request.Request) { v := os.Getenv(execEnvVar) if len(v) == 0 { return } request.AddToUserAgent(r, execEnvUAKey+"/"+v) }, } var AddAwsInternal = request.NamedHandler{ Name: "core.AddAwsInternal", Fn: func(r request.Request) { if len(isAwsInternal) == 0 { return } request.AddToUserAgent(r, isAwsInternal) }, }	1.18 KB	2025-05-25 12:27
📄 user_agent_test.go package corehandlers import ( "net/http" "os" "testing" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/internal/sdktesting" ) func TestAddHostExecEnvUserAgentHander(t *testing.T) { cases := []struct { ExecEnv string Expect string }{ {ExecEnv: "Lambda", Expect: execEnvUAKey + "/Lambda"}, {ExecEnv: "", Expect: ""}, {ExecEnv: "someThingCool", Expect: execEnvUAKey + "/someThingCool"}, } for i, c := range cases { sdktesting.StashEnv() os.Setenv(execEnvVar, c.ExecEnv) req := &request.Request{ HTTPRequest: &http.Request{ Header: http.Header{}, }, } AddHostExecEnvUserAgentHander.Fn(req) if err := req.Error; err != nil { t.Fatalf("%d, expect no error, got %v", i, err) } if e, a := c.Expect, req.HTTPRequest.Header.Get("User-Agent"); e != a { t.Errorf("%d, expect %v user agent, got %v", i, e, a) } } }	884 B	2025-05-25 12:27

Terminal