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
📄 api.go //go:build codegen // +build codegen // Package api represents API abstractions for rendering service generated files. package api import ( "bytes" "fmt" "path" "regexp" "sort" "strings" "text/template" "unicode" ) // SDKImportRoot is the root import path of the SDK. const SDKImportRoot = "github.com/aws/aws-sdk-go" // An API defines a service API's definition. and logic to serialize the definition. type API struct { Metadata Metadata Operations map[string]Operation Shapes map[string]Shape Waiters []Waiter Documentation string `json:"-"` Examples Examples SmokeTests SmokeTestSuite IgnoreUnsupportedAPIs bool // Set to true to avoid removing unused shapes NoRemoveUnusedShapes bool // Set to true to avoid renaming to 'Input/Output' postfixed shapes NoRenameToplevelShapes bool // Set to true to ignore service/request init methods (for testing) NoInitMethods bool // Set to true to ignore String() and GoString methods (for generated tests) NoStringerMethods bool // Set to true to not generate API service name constants NoConstServiceNames bool // Set to true to not generate validation shapes NoValidataShapeMethods bool // Set to true to not generate struct field accessors NoGenStructFieldAccessors bool // Set to not remove unsupported (non-legacy) JSON from API, (for generated tests). NoRemoveUnsupportedJSONValue bool BaseImportPath string initialized bool imports map[string]bool name string path string BaseCrosslinkURL string HasEventStream bool `json:"-"` EndpointDiscoveryOp Operation HasEndpointARN bool `json:"-"` HasOutpostID bool `json:"-"` HasAccountIdWithARN bool `json:"-"` WithGeneratedTypedErrors bool // Set to true to strictly enforce usage of the serviceId for the package naming StrictServiceId bool } // A Metadata is the metadata about an API's definition. type Metadata struct { APIVersion string EndpointPrefix string SigningName string ServiceAbbreviation string ServiceFullName string SignatureVersion string JSONVersion string TargetPrefix string Protocol string ProtocolSettings ProtocolSettings UID string EndpointsID string ServiceID string NoResolveEndpoint bool AWSQueryCompatible awsQueryCompatible } type awsQueryCompatible struct{} // ProtocolSettings define how the SDK should handle requests in the context // of of a protocol. type ProtocolSettings struct { HTTP2 string `json:"h2,omitempty"` } // PackageName name of the API package func (a API) PackageName() string { return strings.ToLower(a.StructName()) } // ImportPath returns the client's full import path func (a API) ImportPath() string { return path.Join(a.BaseImportPath, a.PackageName()) } // InterfacePackageName returns the package name for the interface. func (a API) InterfacePackageName() string { return a.PackageName() + "iface" } var stripServiceNamePrefixes = []string{ "Amazon", "AWS", } // StructName returns the struct name for a given API. func (a API) StructName() string { if len(a.name) != 0 { return a.name } var name string if a.StrictServiceId { name = a.Metadata.ServiceID if len(name) == 0 { panic("expect serviceId to be set, but was not") } if legacyName, ok := legacyStructNames[strings.ToLower(name)]; ok { // The legacy names come from service abbreviations or service full names, // so we will want to apply the old procedure to them. name = makeLikeServiceId(legacyName) } } else { name = a.Metadata.ServiceAbbreviation if len(name) == 0 { name = a.Metadata.ServiceFullName } // If we aren't using the strictly modeled service id, then // strip out prefix names not reflected in service client symbol names. name = makeLikeServiceId(name) } name = strings.TrimSpace(name) // Replace all Non-letter/number values with space runes := []rune(name) for i := 0; i < len(runes); i++ { if r := runes[i]; !(unicode.IsNumber(r) \|\| unicode.IsLetter(r)) { runes[i] = ' ' } } name = string(runes) // Title case name so its readable as a symbol. name = strings.Title(name) // Strip out spaces. name = strings.Replace(name, " ", "", -1) a.name = name return a.name } // UseInitMethods returns if the service's init method should be rendered. func (a API) UseInitMethods() bool { return !a.NoInitMethods } // NiceName returns the human friendly API name. func (a API) NiceName() string { if a.Metadata.ServiceAbbreviation != "" { return a.Metadata.ServiceAbbreviation } return a.Metadata.ServiceFullName } // ProtocolPackage returns the package name of the protocol this API uses. func (a API) ProtocolPackage() string { switch a.Metadata.Protocol { case "json": return "jsonrpc" case "ec2": return "ec2query" default: return strings.Replace(a.Metadata.Protocol, "-", "", -1) } } // OperationNames returns a slice of API operations supported. func (a API) OperationNames() []string { i, names := 0, make([]string, len(a.Operations)) for n := range a.Operations { names[i] = n i++ } sort.Strings(names) return names } // OperationList returns a slice of API operation pointers func (a API) OperationList() []Operation { list := make([]Operation, len(a.Operations)) for i, n := range a.OperationNames() { list[i] = a.Operations[n] } return list } // OperationHasOutputPlaceholder returns if any of the API operation input // or output shapes are place holders. func (a API) OperationHasOutputPlaceholder() bool { for _, op := range a.Operations { if op.OutputRef.Shape.Placeholder { return true } } return false } // ShapeNames returns a slice of names for each shape used by the API. func (a API) ShapeNames() []string { i, names := 0, make([]string, len(a.Shapes)) for n := range a.Shapes { names[i] = n i++ } sort.Strings(names) return names } // ShapeList returns a slice of shape pointers used by the API. // // Will exclude error shapes from the list of shapes returned. func (a API) ShapeList() []Shape { list := make([]Shape, 0, len(a.Shapes)) for _, n := range a.ShapeNames() { // Ignore non-eventstream exception shapes in list. if s := a.Shapes[n]; !(s.Exception && len(s.EventFor) == 0) { list = append(list, s) } } return list } // ShapeListErrors returns a list of the errors defined by the API model func (a API) ShapeListErrors() []Shape { list := []Shape{} for _, n := range a.ShapeNames() { // Ignore error shapes in list if s := a.Shapes[n]; s.Exception { list = append(list, s) } } return list } // resetImports resets the import map to default values. func (a API) resetImports() { a.imports = map[string]bool{} } // importsGoCode returns the generated Go import code. func (a API) importsGoCode() string { if len(a.imports) == 0 { return "" } corePkgs, extPkgs := []string{}, []string{} for i := range a.imports { if strings.Contains(i, ".") { extPkgs = append(extPkgs, i) } else { corePkgs = append(corePkgs, i) } } sort.Strings(corePkgs) sort.Strings(extPkgs) code := "import (\n" for _, i := range corePkgs { code += fmt.Sprintf("\t%q\n", i) } if len(corePkgs) > 0 { code += "\n" } for _, i := range extPkgs { code += fmt.Sprintf("\t%q\n", i) } code += ")\n\n" return code } // A tplAPI is the top level template for the API var tplAPI = template.Must(template.New("api").Parse(` {{- range $_, $o := .OperationList }} {{ $o.GoCode }} {{- end }} {{- range $_, $s := $.Shapes }} {{- if and $s.IsInternal (eq $s.Type "structure") (not $s.Exception) }} {{ $s.GoCode }} {{- else if and $s.Exception (or $.WithGeneratedTypedErrors $s.EventFor) }} {{ $s.GoCode }} {{- end }} {{- end }} {{- range $_, $s := $.Shapes }} {{- if $s.IsEnum }} {{ $s.GoCode }} {{- end }} {{- end }} `)) // AddImport adds the import path to the generated file's import. func (a API) AddImport(v string) error { a.imports[v] = true return nil } // AddSDKImport adds a SDK package import to the generated file's import. func (a API) AddSDKImport(v ...string) error { e := make([]string, 0, 5) e = append(e, SDKImportRoot) e = append(e, v...) a.imports[path.Join(e...)] = true return nil } // APIGoCode renders the API in Go code. Returning it as a string func (a API) APIGoCode() string { a.resetImports() a.AddSDKImport("aws") a.AddSDKImport("aws/awsutil") a.AddSDKImport("aws/request") if a.HasEndpointARN { a.AddImport("fmt") if a.PackageName() == "s3" \|\| a.PackageName() == "s3control" { a.AddSDKImport("internal/s3shared/arn") } else { a.AddSDKImport("service", a.PackageName(), "internal", "arn") } } var buf bytes.Buffer err := tplAPI.Execute(&buf, a) if err != nil { panic(err) } code := a.importsGoCode() + strings.TrimSpace(buf.String()) return code } var noCrossLinkServices = map[string]struct{}{ "apigateway": {}, "budgets": {}, "cloudsearch": {}, "cloudsearchdomain": {}, "elastictranscoder": {}, "elasticsearchservice": {}, "glacier": {}, "importexport": {}, "iot": {}, "iotdataplane": {}, "machinelearning": {}, "rekognition": {}, "sdb": {}, "swf": {}, } // HasCrosslinks will return whether or not a service has crosslinking . func HasCrosslinks(service string) bool { _, ok := noCrossLinkServices[service] return !ok } // GetCrosslinkURL returns the crosslinking URL for the shape based on the name and // uid provided. Empty string is returned if no crosslink link could be determined. func (a API) GetCrosslinkURL(params ...string) string { baseURL := a.BaseCrosslinkURL uid := a.Metadata.UID if a.Metadata.UID == "" \|\| a.BaseCrosslinkURL == "" { return "" } if !HasCrosslinks(strings.ToLower(a.PackageName())) { return "" } return strings.Join(append([]string{baseURL, "goto", "WebAPI", uid}, params...), "/") } // ServiceIDFromUID will parse the service id from the uid and return // the service id that was found. func ServiceIDFromUID(uid string) string { found := 0 i := len(uid) - 1 for ; i >= 0; i-- { if uid[i] == '-' { found++ } // Terminate after the date component is found, e.g. es-2017-11-11 if found == 3 { break } } return uid[0:i] } // APIName returns the API's service name. func (a API) APIName() string { return a.name } var tplServiceDoc = template.Must(template.New("service docs"). Parse(` // Package {{ .PackageName }} provides the client and types for making API // requests to {{ .Metadata.ServiceFullName }}. {{ if .Documentation -}} // {{ .Documentation }} {{ end -}} {{ $crosslinkURL := $.GetCrosslinkURL -}} {{ if $crosslinkURL -}} // // See {{ $crosslinkURL }} for more information on this service. {{ end -}} // // See {{ .PackageName }} package documentation for more information. // https://docs.aws.amazon.com/sdk-for-go/api/service/{{ .PackageName }}/ // // Using the Client // // To contact {{ .Metadata.ServiceFullName }} with the SDK use the New function to create // a new service client. With that client you can make API requests to the service. // These clients are safe to use concurrently. // // See the SDK's documentation for more information on how to use the SDK. // https://docs.aws.amazon.com/sdk-for-go/api/ // // See aws.Config documentation for more information on configuring SDK clients. // https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config // // See the {{ .Metadata.ServiceFullName }} client {{ .StructName }} for more // information on creating client for this service. // https://docs.aws.amazon.com/sdk-for-go/api/service/{{ .PackageName }}/#New `)) var serviceIDRegex = regexp.MustCompile("[^a-zA-Z0-9 ]+") var prefixDigitRegex = regexp.MustCompile("^[0-9]+") // ServiceID will return a unique identifier specific to a service. func ServiceID(a API) string { if len(a.Metadata.ServiceID) > 0 { return a.Metadata.ServiceID } name := a.Metadata.ServiceAbbreviation if len(name) == 0 { name = a.Metadata.ServiceFullName } name = strings.Replace(name, "Amazon", "", -1) name = strings.Replace(name, "AWS", "", -1) name = serviceIDRegex.ReplaceAllString(name, "") name = prefixDigitRegex.ReplaceAllString(name, "") name = strings.TrimSpace(name) return name } // A tplService defines the template for the service generated code. var tplService = template.Must(template.New("service").Funcs(template.FuncMap{ "ServiceNameConstValue": ServiceName, "ServiceNameValue": func(a API) string { if !a.NoConstServiceNames { return "ServiceName" } return fmt.Sprintf("%q", ServiceName(a)) }, "EndpointsIDConstValue": func(a API) string { if a.NoConstServiceNames { return fmt.Sprintf("%q", a.Metadata.EndpointsID) } if a.Metadata.EndpointsID == ServiceName(a) { return "ServiceName" } return fmt.Sprintf("%q", a.Metadata.EndpointsID) }, "EndpointsIDValue": func(a API) string { if a.NoConstServiceNames { return fmt.Sprintf("%q", a.Metadata.EndpointsID) } return "EndpointsID" }, "ServiceIDVar": func(a API) string { if a.NoConstServiceNames { return fmt.Sprintf("%q", ServiceID(a)) } return "ServiceID" }, "ServiceID": ServiceID, }).Parse(` // {{ .StructName }} provides the API operation methods for making requests to // {{ .Metadata.ServiceFullName }}. See this package's package overview docs // for details on the service. // // {{ .StructName }} methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type {{ .StructName }} struct { client.Client {{- if .EndpointDiscoveryOp }} endpointCache crr.EndpointCache {{ end -}} } {{ if .UseInitMethods }}// Used for custom client initialization logic var initClient func(client.Client) // Used for custom request initialization logic var initRequest func(request.Request) {{ end }} {{ if not .NoConstServiceNames -}} // Service information constants const ( ServiceName = "{{ ServiceNameConstValue . }}" // Name of service. EndpointsID = {{ EndpointsIDConstValue . }} // ID to lookup a service endpoint with. ServiceID = "{{ ServiceID . }}" // ServiceID is a unique identifier of a specific service. ) {{- end }} // New creates a new instance of the {{ .StructName }} client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // mySession := session.Must(session.NewSession()) // // // Create a {{ .StructName }} client from just a session. // svc := {{ .PackageName }}.New(mySession) // // // Create a {{ .StructName }} client with additional configuration // svc := {{ .PackageName }}.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func New(p client.ConfigProvider, cfgs ...aws.Config) {{ .StructName }} { {{ if .Metadata.NoResolveEndpoint -}} var c client.Config if v, ok := p.(client.ConfigNoResolveEndpointProvider); ok { c = v.ClientConfigNoResolveEndpoint(cfgs...) } else { c = p.ClientConfig({{ EndpointsIDValue . }}, cfgs...) } {{- else -}} c := p.ClientConfig({{ EndpointsIDValue . }}, cfgs...) {{- end }} if c.SigningNameDerived \|\| len(c.SigningName) == 0 { {{- if .Metadata.SigningName }} c.SigningName = "{{ .Metadata.SigningName }}" {{- else }} {{- if not .NoConstServiceNames -}} c.SigningName = {{ EndpointsIDValue . }} // No Fallback {{- end }} {{- end }} } return newClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) {{ .StructName }} { svc := &{{ .StructName }}{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: {{ ServiceNameValue . }}, ServiceID : {{ ServiceIDVar . }}, SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "{{ .Metadata.APIVersion }}", ResolvedRegion: resolvedRegion, {{ if and (.Metadata.JSONVersion) (eq .Metadata.Protocol "json") -}} JSONVersion: "{{ .Metadata.JSONVersion }}", {{- end }} {{ if and (.Metadata.TargetPrefix) (eq .Metadata.Protocol "json") -}} TargetPrefix: "{{ .Metadata.TargetPrefix }}", {{- end }} }, handlers, ), } {{- if .EndpointDiscoveryOp }} svc.endpointCache = crr.NewEndpointCache(10) {{- end }} // Handlers svc.Handlers.Sign.PushBackNamed( {{- if eq .Metadata.SignatureVersion "v2" -}} v2.SignRequestHandler {{- else if or (eq .Metadata.SignatureVersion "s3") (eq .Metadata.SignatureVersion "s3v4") -}} v4.BuildNamedHandler(v4.SignRequestHandler.Name, func(s v4.Signer) { s.DisableURIPathEscaping = true }) {{- else -}} v4.SignRequestHandler {{- end -}} ) {{- if eq .Metadata.SignatureVersion "v2" }} svc.Handlers.Sign.PushBackNamed(corehandlers.BuildContentLengthHandler) {{- end }} svc.Handlers.Build.PushBackNamed({{ .ProtocolPackage }}.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed({{ .ProtocolPackage }}.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed({{ .ProtocolPackage }}.UnmarshalMetaHandler) {{- if and $.WithGeneratedTypedErrors (gt (len $.ShapeListErrors) 0) }} {{- $_ := $.AddSDKImport "private/protocol" }} svc.Handlers.UnmarshalError.PushBackNamed( {{- if .Metadata.AWSQueryCompatible }} protocol.NewUnmarshalErrorHandler({{ .ProtocolPackage }}.NewUnmarshalTypedErrorWithOptions(exceptionFromCode, {{ .ProtocolPackage }}.WithQueryCompatibility(queryExceptionFromCode))).NamedHandler(), {{- else }} protocol.NewUnmarshalErrorHandler({{ .ProtocolPackage }}.NewUnmarshalTypedError(exceptionFromCode)).NamedHandler(), {{- end}} ) {{- else }} svc.Handlers.UnmarshalError.PushBackNamed({{ .ProtocolPackage }}.UnmarshalErrorHandler) {{- end }} {{- if .HasEventStream }} svc.Handlers.BuildStream.PushBackNamed({{ .ProtocolPackage }}.BuildHandler) svc.Handlers.UnmarshalStream.PushBackNamed({{ .ProtocolPackage }}.UnmarshalHandler) {{- end }} {{- if .UseInitMethods }} // Run custom client initialization if present if initClient != nil { initClient(svc.Client) } {{- end }} return svc } // newRequest creates a new request for a {{ .StructName }} operation and runs any // custom request initialization. func (c {{ .StructName }}) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) {{- if .UseInitMethods }} // Run custom request initialization if present if initRequest != nil { initRequest(req) } {{- end }} return req } `)) // ServicePackageDoc generates the contents of the doc file for the service. // // Will also read in the custom doc templates for the service if found. func (a API) ServicePackageDoc() string { a.imports = map[string]bool{} var buf bytes.Buffer if err := tplServiceDoc.Execute(&buf, a); err != nil { panic(err) } return buf.String() } // ServiceGoCode renders service go code. Returning it as a string. func (a API) ServiceGoCode() string { a.resetImports() a.AddSDKImport("aws") a.AddSDKImport("aws/client") a.AddSDKImport("aws/client/metadata") a.AddSDKImport("aws/request") if a.Metadata.SignatureVersion == "v2" { a.AddSDKImport("private/signer/v2") a.AddSDKImport("aws/corehandlers") } else { a.AddSDKImport("aws/signer/v4") } a.AddSDKImport("private/protocol", a.ProtocolPackage()) if a.EndpointDiscoveryOp != nil { a.AddSDKImport("aws/crr") } var buf bytes.Buffer err := tplService.Execute(&buf, a) if err != nil { panic(err) } code := a.importsGoCode() + buf.String() return code } // ExampleGoCode renders service example code. Returning it as a string. func (a API) ExampleGoCode() string { exs := []string{} imports := map[string]bool{} for _, o := range a.OperationList() { o.imports = map[string]bool{} exs = append(exs, o.Example()) for k, v := range o.imports { imports[k] = v } } code := fmt.Sprintf("import (\n%q\n%q\n%q\n\n%q\n%q\n%q\n", "bytes", "fmt", "time", SDKImportRoot+"/aws", SDKImportRoot+"/aws/session", a.ImportPath(), ) for k := range imports { code += fmt.Sprintf("%q\n", k) } code += ")\n\n" code += "var _ time.Duration\nvar _ bytes.Buffer\n\n" code += strings.Join(exs, "\n\n") return code } // A tplInterface defines the template for the service interface type. var tplInterface = template.Must(template.New("interface").Parse(` // {{ .StructName }}API provides an interface to enable mocking the // {{ .PackageName }}.{{ .StructName }} service client's API operation, // paginators, and waiters. This make unit testing your code that calls out // to the SDK's service client's calls easier. // // The best way to use this interface is so the SDK's service client's calls // can be stubbed out for unit testing your code with the SDK without needing // to inject custom request handlers into the SDK's request pipeline. // // // myFunc uses an SDK service client to make a request to // // {{.Metadata.ServiceFullName}}. {{ $opts := .OperationList }}{{ $opt := index $opts 0 }} // func myFunc(svc {{ .InterfacePackageName }}.{{ .StructName }}API) bool { // // Make svc.{{ $opt.ExportedName }} request // } // // func main() { // sess := session.New() // svc := {{ .PackageName }}.New(sess) // // myFunc(svc) // } // // In your _test.go file: // // // Define a mock struct to be used in your unit tests of myFunc. // type mock{{ .StructName }}Client struct { // {{ .InterfacePackageName }}.{{ .StructName }}API // } // func (m mock{{ .StructName }}Client) {{ $opt.ExportedName }}(input {{ $opt.InputRef.GoTypeWithPkgName }}) ({{ $opt.OutputRef.GoTypeWithPkgName }}, error) { // // mock response/functionality // } // // func TestMyFunc(t testing.T) { // // Setup Test // mockSvc := &mock{{ .StructName }}Client{} // // myfunc(mockSvc) // // // Verify myFunc's functionality // } // // It is important to note that this interface will have breaking changes // when the service model is updated and adds new API operations, paginators, // and waiters. Its suggested to use the pattern above for testing, or using // tooling to generate mocks to satisfy the interfaces. type {{ .StructName }}API interface { {{ range $_, $o := .OperationList }} {{ $o.InterfaceSignature }} {{ end }} {{ range $_, $w := .Waiters }} {{ $w.InterfaceSignature }} {{ end }} } var _ {{ .StructName }}API = ({{ .PackageName }}.{{ .StructName }})(nil) `)) // InterfaceGoCode returns the go code for the service's API operations as an // interface{}. Assumes that the interface is being created in a different // package than the service API's package. func (a API) InterfaceGoCode() string { a.resetImports() a.AddSDKImport("aws") a.AddSDKImport("aws/request") a.AddImport(a.ImportPath()) var buf bytes.Buffer err := tplInterface.Execute(&buf, a) if err != nil { panic(err) } code := a.importsGoCode() + strings.TrimSpace(buf.String()) return code } // NewAPIGoCodeWithPkgName returns a string of instantiating the API prefixed // with its package name. Takes a string depicting the Config. func (a API) NewAPIGoCodeWithPkgName(cfg string) string { return fmt.Sprintf("%s.New(%s)", a.PackageName(), cfg) } // computes the validation chain for all input shapes func (a API) addShapeValidations() { for _, o := range a.Operations { resolveShapeValidations(o.InputRef.Shape) } } // Updates the source shape and all nested shapes with the validations that // could possibly be needed. func resolveShapeValidations(s Shape, ancestry ...Shape) { for _, a := range ancestry { if a == s { return } } children := []string{} for _, name := range s.MemberNames() { ref := s.MemberRefs[name] if s.IsRequired(name) && !s.Validations.Has(ref, ShapeValidationRequired) { s.Validations = append(s.Validations, ShapeValidation{ Name: name, Ref: ref, Type: ShapeValidationRequired, }) } if ref.Shape.Min != 0 && !s.Validations.Has(ref, ShapeValidationMinVal) { s.Validations = append(s.Validations, ShapeValidation{ Name: name, Ref: ref, Type: ShapeValidationMinVal, }) } if !ref.CanBeEmpty() && !s.Validations.Has(ref, ShapeValidationMinVal) { s.Validations = append(s.Validations, ShapeValidation{ Name: name, Ref: ref, Type: ShapeValidationMinVal, }) } switch ref.Shape.Type { case "map", "list", "structure": children = append(children, name) } } ancestry = append(ancestry, s) for _, name := range children { ref := s.MemberRefs[name] // Since this is a grab bag we will just continue since // we can't validate because we don't know the valued shape. if ref.JSONValue \|\| (s.UsedAsInput && ref.Shape.IsEventStream) { continue } nestedShape := ref.Shape.NestedShape() var v ShapeValidation if len(nestedShape.Validations) > 0 { v = &ShapeValidation{ Name: name, Ref: ref, Type: ShapeValidationNested, } } else { resolveShapeValidations(nestedShape, ancestry...) if len(nestedShape.Validations) > 0 { v = &ShapeValidation{ Name: name, Ref: ref, Type: ShapeValidationNested, } } } if v != nil && !s.Validations.Has(v.Ref, v.Type) { s.Validations = append(s.Validations, v) } } ancestry = ancestry[:len(ancestry)-1] } // A tplAPIErrors is the top level template for the API var tplAPIErrors = template.Must(template.New("api").Parse(` const ( {{- range $_, $s := $.ShapeListErrors }} // {{ $s.ErrorCodeName }} for service response error code // {{ printf "%q" $s.ErrorName }}. {{ if $s.Docstring -}} // {{ $s.Docstring }} {{ end -}} {{ $s.ErrorCodeName }} = {{ printf "%q" $s.ErrorName }} {{- end }} ) {{- if $.WithGeneratedTypedErrors }} {{- $_ := $.AddSDKImport "private/protocol" }} var exceptionFromCode = map[string]func(protocol.ResponseMetadata)error { {{- range $_, $s := $.ShapeListErrors }} "{{ $s.ErrorName }}": newError{{ $s.ShapeName }}, {{- end }} } {{- if .Metadata.AWSQueryCompatible }} var queryExceptionFromCode = map[string]func(protocol.ResponseMetadata, string)error { {{- range $_, $s := $.ShapeListErrors }} "{{ $s.ErrorName }}": newQueryCompatibleError{{ $s.ShapeName }}, {{- end }} } {{- end }} {{- end }} `)) // A tplAPIErrors is the top level template for the API var tplAPIErrorsSQS = template.Must(template.New("api").Parse(` const ( {{- range $_, $s := $.ShapeListErrors }} // {{ $s.ErrorCodeName }} for service response error code {{- if eq $s.ErrorCodeName "ErrCodeBatchEntryIdsNotDistinct" }} // "AWS.SimpleQueueService.BatchEntryIdsNotDistinct". {{- else if eq $s.ErrorCodeName "ErrCodeBatchRequestTooLong" }} // "AWS.SimpleQueueService.BatchRequestTooLong". {{- else if eq $s.ErrorCodeName "ErrCodeEmptyBatchRequest" }} // "AWS.SimpleQueueService.EmptyBatchRequest". {{- else if eq $s.ErrorCodeName "ErrCodeInvalidBatchEntryId" }} // "AWS.SimpleQueueService.InvalidBatchEntryId". {{- else if eq $s.ErrorCodeName "ErrCodeMessageNotInflight" }} // "AWS.SimpleQueueService.MessageNotInflight". {{- else if eq $s.ErrorCodeName "ErrCodePurgeQueueInProgress" }} // "AWS.SimpleQueueService.PurgeQueueInProgress". {{- else if eq $s.ErrorCodeName "ErrCodeQueueDeletedRecently" }} // "AWS.SimpleQueueService.QueueDeletedRecently". {{- else if eq $s.ErrorCodeName "ErrCodeQueueDoesNotExist" }} // "AWS.SimpleQueueService.NonExistentQueue". {{- else if eq $s.ErrorCodeName "ErrCodeTooManyEntriesInBatchRequest" }} // "AWS.SimpleQueueService.TooManyEntriesInBatchRequest". {{- else if eq $s.ErrorCodeName "ErrCodeUnsupportedOperation" }} // "AWS.SimpleQueueService.UnsupportedOperation". {{- else if eq $s.ErrorCodeName "ErrCodeQueueNameExists" }} // "QueueAlreadyExists". {{- else }} // {{ printf "%q" $s.ErrorName }}. {{- end }} {{ if $s.Docstring -}} // {{ $s.Docstring }} {{ end -}} {{- if eq $s.ErrorCodeName "ErrCodeBatchEntryIdsNotDistinct" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.BatchEntryIdsNotDistinct" {{- else if eq $s.ErrorCodeName "ErrCodeBatchRequestTooLong" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.BatchRequestTooLong" {{- else if eq $s.ErrorCodeName "ErrCodeEmptyBatchRequest" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.EmptyBatchRequest" {{- else if eq $s.ErrorCodeName "ErrCodeInvalidBatchEntryId" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.InvalidBatchEntryId" {{- else if eq $s.ErrorCodeName "ErrCodeMessageNotInflight" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.MessageNotInflight" {{- else if eq $s.ErrorCodeName "ErrCodePurgeQueueInProgress" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.PurgeQueueInProgress" {{- else if eq $s.ErrorCodeName "ErrCodeQueueDeletedRecently" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.QueueDeletedRecently" {{- else if eq $s.ErrorCodeName "ErrCodeQueueDoesNotExist" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.NonExistentQueue" {{- else if eq $s.ErrorCodeName "ErrCodeTooManyEntriesInBatchRequest" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.TooManyEntriesInBatchRequest" {{- else if eq $s.ErrorCodeName "ErrCodeUnsupportedOperation" -}} {{ $s.ErrorCodeName }} = "AWS.SimpleQueueService.UnsupportedOperation" {{- else if eq $s.ErrorCodeName "ErrCodeQueueNameExists" -}} {{ $s.ErrorCodeName }} = "QueueAlreadyExists" {{- else -}} {{ $s.ErrorCodeName }} = {{ printf "%q" $s.ErrorName }} {{- end -}} {{- end }} ) {{- if $.WithGeneratedTypedErrors }} {{- $_ := $.AddSDKImport "private/protocol" }} var exceptionFromCode = map[string]func(protocol.ResponseMetadata)error { {{- range $_, $s := $.ShapeListErrors }} "{{ $s.ErrorName }}": newError{{ $s.ShapeName }}, {{- end }} } {{- if .Metadata.AWSQueryCompatible }} var queryExceptionFromCode = map[string]func(protocol.ResponseMetadata, string)error { {{- range $_, $s := $.ShapeListErrors }} "{{ $s.ErrorName }}": newQueryCompatibleError{{ $s.ShapeName }}, {{- end }} } {{- end }} {{- end }} `)) // APIErrorsGoCode returns the Go code for the errors.go file. func (a API) APIErrorsGoCode() string { a.resetImports() var buf bytes.Buffer var err error if a.Metadata.ServiceID == "SQS" { err = tplAPIErrorsSQS.Execute(&buf, a) } else { err = tplAPIErrors.Execute(&buf, a) } if err != nil { panic(err) } return a.importsGoCode() + strings.TrimSpace(buf.String()) } // removeOperation removes an operation, its input/output shapes, as well as // any references/shapes that are unique to this operation. func (a API) removeOperation(name string) { debugLogger.Logln("removing operation,", name) op := a.Operations[name] delete(a.Operations, name) delete(a.Examples, name) a.removeShape(op.InputRef.Shape) a.removeShape(op.OutputRef.Shape) } // removeShape removes the given shape, and all form member's reference target // shapes. Will also remove member reference targeted shapes if those shapes do // not have any additional references. func (a API) removeShape(s Shape) { debugLogger.Logln("removing shape,", s.ShapeName) delete(a.Shapes, s.ShapeName) for name, ref := range s.MemberRefs { a.removeShapeRef(ref) delete(s.MemberRefs, name) } for _, ref := range []ShapeRef{&s.MemberRef, &s.KeyRef, &s.ValueRef} { if ref.Shape == nil { continue } a.removeShapeRef(ref) ref = ShapeRef{} } } // removeShapeRef removes the shape reference from its target shape. If the // reference was the last reference to the target shape, the shape will also be // removed. func (a API) removeShapeRef(ref ShapeRef) { if ref.Shape == nil { return } ref.Shape.removeRef(ref) if len(ref.Shape.refs) == 0 { a.removeShape(ref.Shape) } } // writeInputOutputLocationName writes the ShapeName to the // shapes LocationName in the event that there is no LocationName // specified. func (a API) writeInputOutputLocationName() { for _, o := range a.Operations { setInput := len(o.InputRef.LocationName) == 0 && a.Metadata.Protocol == "rest-xml" setOutput := len(o.OutputRef.LocationName) == 0 && (a.Metadata.Protocol == "rest-xml" \|\| a.Metadata.Protocol == "ec2") if setInput { o.InputRef.LocationName = o.InputRef.Shape.OrigShapeName } if setOutput { o.OutputRef.LocationName = o.OutputRef.Shape.OrigShapeName } } } func (a API) addHeaderMapDocumentation() { for _, shape := range a.Shapes { if !shape.UsedAsOutput { continue } for _, shapeRef := range shape.MemberRefs { if shapeRef.Location == "headers" { if dLen := len(shapeRef.Documentation); dLen > 0 { if shapeRef.Documentation[dLen-1] != '\n' { shapeRef.Documentation += "\n" } shapeRef.Documentation += "//" } shapeRef.Documentation += ` // By default unmarshaled keys are written as a map keys in following canonicalized format: // the first letter and any letter following a hyphen will be capitalized, and the rest as lowercase. // Set ` + "`aws.Config.LowerCaseHeaderMaps`" + ` to ` + "`true`" + ` to write unmarshaled keys to the map as lowercase. ` } } } } func (a API) validateNoDocumentShapes() error { var shapes []string for name, shape := range a.Shapes { if shape.Type != "structure" { continue } if shape.Document { shapes = append(shapes, name) } } if len(shapes) == 0 { return nil } return fmt.Errorf("model contains document shapes: %s", strings.Join(shapes, ", ")) } func (a API) backfillSigningName() { backfill := map[string]string{ "kinesisvideo": "kinesisvideo", } if value, ok := backfill[a.PackageName()]; ok && len(a.Metadata.SigningName) == 0 { a.Metadata.SigningName = value } else if ok && len(a.Metadata.SigningName) > 0 { debugLogger.Logf("%s no longer requires signingName backfill", a.PackageName()) } } func getDeprecatedMessage(msg string, name string) string { if len(msg) == 0 { return name + " has been deprecated" } return msg } func makeLikeServiceId(name string) string { for _, prefix := range stripServiceNamePrefixes { if strings.HasPrefix(name, prefix) { name = name[len(prefix):] break } } return name }	33.81 KB	2025-05-25 12:27
📄 api_test.go //go:build go1.8 && codegen // +build go1.8,codegen package api import ( "strings" "testing" ) func TestAPI_StructName(t testing.T) { origAliases := serviceAliaseNames defer func() { serviceAliaseNames = origAliases }() cases := map[string]struct { Aliases map[string]string Metadata Metadata StructName string }{ "FullName": { Metadata: Metadata{ ServiceFullName: "Amazon Service Name-100", }, StructName: "ServiceName100", }, "Abbreviation": { Metadata: Metadata{ ServiceFullName: "Amazon Service Name-100", ServiceAbbreviation: "AWS SN100", }, StructName: "SN100", }, "Lowercase Name": { Metadata: Metadata{ EndpointPrefix: "other", ServiceFullName: "AWS Lowercase service", ServiceAbbreviation: "lowercase", }, StructName: "Lowercase", }, "Lowercase Name Mixed": { Metadata: Metadata{ EndpointPrefix: "other", ServiceFullName: "AWS Lowercase service", ServiceAbbreviation: "lowercase name Goes heRe", }, StructName: "LowercaseNameGoesHeRe", }, "Alias": { Aliases: map[string]string{ "elasticloadbalancing": "ELB", }, Metadata: Metadata{ ServiceFullName: "Elastic Load Balancing", }, StructName: "ELB", }, } for k, c := range cases { t.Run(k, func(t testing.T) { serviceAliaseNames = c.Aliases a := API{ Metadata: c.Metadata, } a.Setup() if e, o := c.StructName, a.StructName(); e != o { t.Errorf("expect %v structName, got %v", e, o) } }) } } func TestAPI_Setup_documentShapes(t testing.T) { api := API{ Shapes: map[string]Shape{ "Document": { Type: "structure", Document: true, }, }, } err := api.Setup() if err == nil { t.Fatalf("expect error, but got nil") } expect := "model contains document shapes" if !strings.Contains(err.Error(), expect) { t.Errorf("expect %s, got %v", expect, err) } }	1.89 KB	2025-05-25 12:27
📁 codegentest	-	2025-05-25 12:27
📄 customization_passes.go //go:build codegen // +build codegen package api import ( "fmt" "io/ioutil" "log" "os" "path/filepath" "strings" ) type service struct { srcName string dstName string serviceVersion string } var mergeServices = map[string]service{ "dynamodbstreams": { dstName: "dynamodb", srcName: "streams.dynamodb", }, "wafregional": { dstName: "waf", srcName: "waf-regional", serviceVersion: "2015-08-24", }, } var serviceAliaseNames = map[string]string{ "costandusagereportservice": "CostandUsageReportService", "elasticloadbalancing": "ELB", "elasticloadbalancingv2": "ELBV2", "config": "ConfigService", } func (a API) setServiceAliaseName() { if newName, ok := serviceAliaseNames[a.PackageName()]; ok { a.name = newName } } // customizationPasses Executes customization logic for the API by package name. func (a API) customizationPasses() error { var svcCustomizations = map[string]func(API) error{ "s3": s3Customizations, "s3control": s3ControlCustomizations, "cloudfront": cloudfrontCustomizations, "rds": rdsCustomizations, "neptune": neptuneCustomizations, "docdb": docdbCustomizations, // Disable endpoint resolving for services that require customer // to provide endpoint them selves. "cloudsearchdomain": disableEndpointResolving, "iotdataplane": disableEndpointResolving, // MTurk smoke test is invalid. The service requires AWS account to be // linked to Amazon Mechanical Turk Account. "mturk": supressSmokeTest, // Backfill the authentication type for cognito identity and sts. // Removes the need for the customizations in these services. "cognitoidentity": backfillAuthType(NoneAuthType, "GetId", "GetOpenIdToken", "UnlinkIdentity", "GetCredentialsForIdentity", ), "sts": backfillAuthType(NoneAuthType, "AssumeRoleWithSAML", "AssumeRoleWithWebIdentity", ), "eventbridge": eventBridgeCustomizations, } for k := range mergeServices { svcCustomizations[k] = mergeServicesCustomizations } if fn := svcCustomizations[a.PackageName()]; fn != nil { err := fn(a) if err != nil { return fmt.Errorf("service customization pass failure for %s: %v", a.PackageName(), err) } } if err := addHTTPChecksumCustomDocumentation(a); err != nil { if err != nil { return fmt.Errorf("service httpChecksum trait customization failed, %s: %v", a.PackageName(), err) } } return nil } func addHTTPChecksumCustomDocumentation(a API) error { for opName, o := range a.Operations { if o.HTTPChecksum.RequestAlgorithmMember != "" { ref := o.InputRef.Shape.GetModeledMember(o.HTTPChecksum.RequestAlgorithmMember) if ref == nil { return fmt.Errorf( "expect httpChecksum.RequestAlgorithmMember %v to be modeled input member for %v", o.HTTPChecksum.RequestAlgorithmMember, opName, ) } ref.Documentation = AppendDocstring(ref.Documentation, ` The AWS SDK for Go v1 does not support automatic computing request payload checksum. This feature is available in the AWS SDK for Go v2. If a value is specified for this parameter, the matching algorithm's checksum member must be populated with the algorithm's checksum of the request payload. `) if o.RequestChecksumRequired() { ref.Documentation = AppendDocstring(ref.Documentation, ` The SDK will automatically compute the Content-MD5 checksum for this operation. The AWS SDK for Go v2 allows you to configure alternative checksum algorithm to be used. `) } } if o.HTTPChecksum.RequestValidationModeMember != "" { ref := o.InputRef.Shape.GetModeledMember(o.HTTPChecksum.RequestValidationModeMember) if ref == nil { return fmt.Errorf( "expect httpChecksum.RequestValidationModeMember %v to be modeled input member for %v", o.HTTPChecksum.RequestValidationModeMember, opName, ) } ref.Documentation = AppendDocstring(ref.Documentation, ` The AWS SDK for Go v1 does not support automatic response payload checksum validation. This feature is available in the AWS SDK for Go v2. `) } } return nil } func eventBridgeCustomizations(a API) error { // Inject documentation to indicate PutEvents API does not support EndpointId routing to a multi-region endpoint // using SigV4a signing. const docAddon = "// This AWS SDK does not support calling multi-region endpoints with SigV4a authentication." var sb strings.Builder op, ok := a.Operations["PutEvents"] if !ok { return nil } op.Documentation = appendDocString(&sb, op.Documentation, docAddon) const putEventsInputShape = "PutEventsInput" input, ok := a.Shapes[putEventsInputShape] if !ok { return nil } const endpointIdMember = "EndpointId" mref, ok := input.MemberRefs[endpointIdMember] if !ok { return nil } mref.Documentation = appendDocString(&sb, mref.Documentation, docAddon) return nil } func appendDocString(sb strings.Builder, doc, content string) string { if len(content) == 0 { return doc } sb.Reset() sb.WriteString(doc) if sb.Len() > 0 { if doc[len(doc)-1] != '\n' { sb.WriteRune('\n') } sb.WriteString("//\n") } sb.WriteString(content) return sb.String() } func supressSmokeTest(a API) error { a.SmokeTests.TestCases = []SmokeTestCase{} return nil } // Customizes the API generation to replace values specific to S3. func s3Customizations(a API) error { // back-fill signing name as 's3' a.Metadata.SigningName = "s3" var strExpires Shape var keepContentMD5Ref = map[string]struct{}{ "PutObjectInput": {}, "UploadPartInput": {}, } for name, s := range a.Shapes { // Remove ContentMD5 members unless specified otherwise. if _, keep := keepContentMD5Ref[name]; !keep { if _, have := s.MemberRefs["ContentMD5"]; have { delete(s.MemberRefs, "ContentMD5") } } // Generate getter methods for API operation fields used by customizations. for _, refName := range []string{"Bucket", "SSECustomerKey", "CopySourceSSECustomerKey"} { if ref, ok := s.MemberRefs[refName]; ok { ref.GenerateGetter = true } } // Generate a endpointARN method for the BucketName shape if this is used as an operation input if s.UsedAsInput { if s.ShapeName == "CreateBucketInput" { // For all operations but CreateBucket the BucketName shape // needs to be decorated. continue } var endpointARNShape ShapeRef for _, ref := range s.MemberRefs { if ref.OrigShapeName != "BucketName" \|\| ref.Shape.Type != "string" { continue } if endpointARNShape != nil { return fmt.Errorf("more then one BucketName shape present on shape") } ref.EndpointARN = true endpointARNShape = ref } if endpointARNShape != nil { s.HasEndpointARNMember = true a.HasEndpointARN = true } } // Decorate member references that are modeled with the wrong type. // Specifically the case where a member was modeled as a string, but is // expected to sent across the wire as a base64 value. // // e.g. S3's SSECustomerKey and CopySourceSSECustomerKey for _, refName := range []string{ "SSECustomerKey", "CopySourceSSECustomerKey", } { if ref, ok := s.MemberRefs[refName]; ok { ref.CustomTags = append(ref.CustomTags, ShapeTag{ "marshal-as", "blob", }) } } // Expires should be a string not time.Time since the format is not // enforced by S3, and any value can be set to this field outside of the SDK. if strings.HasSuffix(name, "Output") { if ref, ok := s.MemberRefs["Expires"]; ok { if strExpires == nil { newShape := ref.Shape strExpires = &newShape strExpires.Type = "string" strExpires.refs = []ShapeRef{} } ref.Shape.removeRef(ref) ref.Shape = strExpires ref.Shape.refs = append(ref.Shape.refs, &s.MemberRef) } } } s3CustRemoveHeadObjectModeledErrors(a) return nil } // S3 HeadObject API call incorrect models NoSuchKey as valid // error code that can be returned. This operation does not // return error codes, all error codes are derived from HTTP // status codes. // // aws/aws-sdk-go#1208 func s3CustRemoveHeadObjectModeledErrors(a API) { op, ok := a.Operations["HeadObject"] if !ok { return } op.Documentation = AppendDocstring(op.Documentation, ` See http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#RESTErrorResponses for more information on returned errors. `) op.ErrorRefs = []ShapeRef{} } // S3 service operations with an AccountId need accessors to be generated for // them so the fields can be dynamically accessed without reflection. func s3ControlCustomizations(a API) error { for _, s := range a.Shapes { // Generate a endpointARN method for the BucketName shape if this is used as an operation input if s.UsedAsInput { if s.ShapeName == "CreateBucketInput" \|\| s.ShapeName == "ListRegionalBucketsInput" { // For operations CreateBucketInput and ListRegionalBuckets the OutpostID shape // needs to be decorated var outpostIDMemberShape ShapeRef for memberName, ref := range s.MemberRefs { if memberName != "OutpostId" \|\| ref.Shape.Type != "string" { continue } if outpostIDMemberShape != nil { return fmt.Errorf("more then one OutpostID shape present on shape") } ref.OutpostIDMember = true outpostIDMemberShape = ref } if outpostIDMemberShape != nil { s.HasOutpostIDMember = true a.HasOutpostID = true } continue } // List of input shapes that use accesspoint names as arnable fields accessPointNameArnables := map[string]struct{}{ "GetAccessPointInput": {}, "DeleteAccessPointInput": {}, "PutAccessPointPolicyInput": {}, "GetAccessPointPolicyInput": {}, "DeleteAccessPointPolicyInput": {}, } var endpointARNShape ShapeRef for _, ref := range s.MemberRefs { // Operations that have AccessPointName field that takes in an ARN as input if _, ok := accessPointNameArnables[s.ShapeName]; ok { if ref.OrigShapeName != "AccessPointName" \|\| ref.Shape.Type != "string" { continue } } else if ref.OrigShapeName != "BucketName" \|\| ref.Shape.Type != "string" { // All other operations currently allow BucketName field to take in ARN. // Exceptions for these are CreateBucket and ListRegionalBucket which use // Outpost id and are handled above separately. continue } if endpointARNShape != nil { return fmt.Errorf("more then one member present on shape takes arn as input") } ref.EndpointARN = true endpointARNShape = ref } if endpointARNShape != nil { s.HasEndpointARNMember = true a.HasEndpointARN = true for _, ref := range s.MemberRefs { // check for account id customization if ref.OrigShapeName == "AccountId" && ref.Shape.Type == "string" { ref.AccountIDMemberWithARN = true s.HasAccountIdMemberWithARN = true a.HasAccountIdWithARN = true } } } } } return nil } // cloudfrontCustomizations customized the API generation to replace values // specific to CloudFront. func cloudfrontCustomizations(a API) error { // MaxItems members should always be integers for _, s := range a.Shapes { if ref, ok := s.MemberRefs["MaxItems"]; ok { ref.ShapeName = "Integer" ref.Shape = a.Shapes["Integer"] } } return nil } // mergeServicesCustomizations references any duplicate shapes from DynamoDB func mergeServicesCustomizations(a API) error { info := mergeServices[a.PackageName()] p := strings.Replace(a.path, info.srcName, info.dstName, -1) if info.serviceVersion != "" { index := strings.LastIndex(p, string(filepath.Separator)) files, _ := ioutil.ReadDir(p[:index]) if len(files) > 1 { panic("New version was introduced") } p = p[:index] + "/" + info.serviceVersion } file := filepath.Join(p, "api-2.json") serviceAPI := API{ IgnoreUnsupportedAPIs: a.IgnoreUnsupportedAPIs, NoRemoveUnusedShapes: a.NoRemoveUnusedShapes, NoRenameToplevelShapes: a.NoRenameToplevelShapes, NoInitMethods: a.NoInitMethods, NoStringerMethods: a.NoStringerMethods, NoConstServiceNames: a.NoConstServiceNames, NoValidataShapeMethods: a.NoValidataShapeMethods, NoGenStructFieldAccessors: a.NoGenStructFieldAccessors, NoRemoveUnsupportedJSONValue: a.NoRemoveUnsupportedJSONValue, StrictServiceId: a.StrictServiceId, } serviceAPI.Attach(file) serviceAPI.Setup() for n := range a.Shapes { if _, ok := serviceAPI.Shapes[n]; ok { a.Shapes[n].resolvePkg = SDKImportRoot + "/service/" + info.dstName } } return nil } // rdsCustomizations are customization for the service/rds. This adds // non-modeled fields used for presigning. func rdsCustomizations(a API) error { inputs := []string{ "CopyDBSnapshotInput", "CreateDBInstanceReadReplicaInput", "CopyDBClusterSnapshotInput", "CreateDBClusterInput", "StartDBInstanceAutomatedBackupsReplicationInput", } generatePresignedURL(a, inputs) return nil } // neptuneCustomizations are customization for the service/neptune. This adds // non-modeled fields used for presigning. func neptuneCustomizations(a API) error { inputs := []string{ "CopyDBClusterSnapshotInput", "CreateDBClusterInput", } generatePresignedURL(a, inputs) return nil } // neptuneCustomizations are customization for the service/neptune. This adds // non-modeled fields used for presigning. func docdbCustomizations(a API) error { inputs := []string{ "CopyDBClusterSnapshotInput", "CreateDBClusterInput", } generatePresignedURL(a, inputs) return nil } func generatePresignedURL(a API, inputShapes []string) { for _, input := range inputShapes { if ref, ok := a.Shapes[input]; ok { ref.MemberRefs["SourceRegion"] = &ShapeRef{ Documentation: docstring(` SourceRegion is the source region where the resource exists. This is not sent over the wire and is only used for presigning. This value should always have the same region as the source ARN. `), ShapeName: "String", Shape: a.Shapes["String"], Ignore: true, } ref.MemberRefs["DestinationRegion"] = &ShapeRef{ Documentation: docstring(` DestinationRegion is used for presigning the request to a given region. `), ShapeName: "String", Shape: a.Shapes["String"], } } } } func disableEndpointResolving(a API) error { a.Metadata.NoResolveEndpoint = true return nil } func backfillAuthType(typ AuthType, opNames ...string) func(API) error { return func(a API) error { for _, opName := range opNames { op, ok := a.Operations[opName] if !ok { panic("unable to backfill auth-type for unknown operation " + opName) } if v := op.AuthType; len(v) != 0 { fmt.Fprintf(os.Stderr, "unable to backfill auth-type for %s, already set, %s\n", opName, v) continue } op.AuthType = typ } return nil } } // Must be invoked with the original shape name func removeUnsupportedJSONValue(a API) error { for shapeName, shape := range a.Shapes { switch shape.Type { case "structure": for refName, ref := range shape.MemberRefs { if !ref.JSONValue { continue } if err := removeUnsupportedShapeRefJSONValue(a, shapeName, refName, ref); err != nil { return fmt.Errorf("failed remove unsupported JSONValue from %v.%v, %v", shapeName, refName, err) } } case "list": if !shape.MemberRef.JSONValue { continue } if err := removeUnsupportedShapeRefJSONValue(a, shapeName, "", &shape.MemberRef); err != nil { return fmt.Errorf("failed remove unsupported JSONValue from %v, %v", shapeName, err) } case "map": if !shape.ValueRef.JSONValue { continue } if err := removeUnsupportedShapeRefJSONValue(a, shapeName, "", &shape.ValueRef); err != nil { return fmt.Errorf("failed remove unsupported JSONValue from %v, %v", shapeName, err) } } } return nil } func removeUnsupportedShapeRefJSONValue(a API, parentName, refName string, ref ShapeRef) (err error) { var found bool defer func() { if !found && err == nil { log.Println("removing JSONValue", a.PackageName(), parentName, refName) ref.JSONValue = false ref.SuppressedJSONValue = true } }() legacyShapes, ok := legacyJSONValueShapes[a.PackageName()] if !ok { return nil } legacyShape, ok := legacyShapes[parentName] if !ok { return nil } switch legacyShape.Type { case "structure": _, ok = legacyShape.StructMembers[refName] found = ok case "list": found = legacyShape.ListMemberRef case "map": found = legacyShape.MapValueRef } return nil }	16.36 KB	2025-05-25 12:27
📄 docstring.go //go:build codegen // +build codegen package api import ( "bufio" "encoding/json" "encoding/xml" "fmt" "html" "io" "log" "os" "regexp" "strings" ) type apiDocumentation struct { Operations map[string]string Service string Shapes map[string]shapeDocumentation } type shapeDocumentation struct { Base string Refs map[string]string } // AttachDocs attaches documentation from a JSON filename. func (a API) AttachDocs(filename string) error { var d apiDocumentation f, err := os.Open(filename) defer f.Close() if err != nil { return err } err = json.NewDecoder(f).Decode(&d) if err != nil { return fmt.Errorf("failed to decode %s, err: %v", filename, err) } return d.setup(a) } func (d apiDocumentation) setup(a API) error { a.Documentation = docstring(d.Service) for opName, doc := range d.Operations { if _, ok := a.Operations[opName]; !ok { continue } a.Operations[opName].Documentation = docstring(doc) } for shapeName, docShape := range d.Shapes { if s, ok := a.Shapes[shapeName]; ok { s.Documentation = docstring(docShape.Base) } for ref, doc := range docShape.Refs { if doc == "" { continue } parts := strings.Split(ref, "$") if len(parts) != 2 { fmt.Fprintf(os.Stderr, "Shape Doc %s has unexpected reference format, %q\n", shapeName, ref) continue } if s, ok := a.Shapes[parts[0]]; ok && len(s.MemberRefs) != 0 { if m, ok := s.MemberRefs[parts[1]]; ok && m.ShapeName == shapeName { m.Documentation = docstring(doc) } } } } return nil } var reNewline = regexp.MustCompile(`\r?\n`) var reMultiSpace = regexp.MustCompile(`\s+`) var reComments = regexp.MustCompile(`<!--.?-->`) var reFullnameBlock = regexp.MustCompile(`<fullname>(.+?)<\/fullname>`) var reFullname = regexp.MustCompile(`<fullname>(.?)</fullname>`) var reExamples = regexp.MustCompile(`<examples?>.+?<\/examples?>`) var reEndNL = regexp.MustCompile(`\n+$`) // docstring rewrites a string to insert godocs formatting. func docstring(doc string) string { doc = strings.TrimSpace(doc) if doc == "" { return "" } doc = reNewline.ReplaceAllString(doc, "") doc = reMultiSpace.ReplaceAllString(doc, " ") doc = reComments.ReplaceAllString(doc, "") var fullname string parts := reFullnameBlock.FindStringSubmatch(doc) if len(parts) > 1 { fullname = parts[1] } // Remove full name block from doc string doc = reFullname.ReplaceAllString(doc, "") doc = reExamples.ReplaceAllString(doc, "") doc = generateDoc(doc) doc = reEndNL.ReplaceAllString(doc, "") doc = html.UnescapeString(doc) // Replace doc with full name if doc is empty. if len(doc) == 0 { doc = fullname } return commentify(doc) } const ( indent = " " ) // commentify converts a string to a Go comment func commentify(doc string) string { if len(doc) == 0 { return "" } lines := strings.Split(doc, "\n") out := make([]string, 0, len(lines)) for i := 0; i < len(lines); i++ { line := lines[i] if i > 0 && line == "" && lines[i-1] == "" { continue } out = append(out, line) } if len(out) > 0 { out[0] = "// " + out[0] return strings.Join(out, "\n// ") } return "" } func wrap(text string, length int) string { var b strings.Builder s := bufio.NewScanner(strings.NewReader(text)) for s.Scan() { line := s.Text() // cleanup the line's spaces var i int for i = 0; i < len(line); i++ { c := line[i] // Ignore leading spaces, e.g indents. if !(c == ' ' \|\| c == '\t') { break } } line = line[:i] + strings.Join(strings.Fields(line[i:]), " ") splitLine(&b, line, length) } return strings.TrimRight(b.String(), "\n") } func splitLine(w stringWriter, line string, length int) { leading := getLeadingWhitespace(line) line = line[len(leading):] length -= len(leading) const splitOn = " " for len(line) > length { // Find the next whitespace to the length idx := strings.Index(line[length:], splitOn) if idx == -1 { break } offset := length + idx if v := line[offset+len(splitOn):]; len(v) == 1 && strings.ContainsAny(v, `,.!?'"`) { // Workaround for long lines with space before the punctuation mark. break } w.WriteString(leading) w.WriteString(line[:offset]) w.WriteByte('\n') line = strings.TrimLeft(line[offset+len(splitOn):], " \t") } if len(line) > 0 { w.WriteString(leading) w.WriteString(line) } // Add the newline back in that was stripped out by scanner. w.WriteByte('\n') } func getLeadingWhitespace(v string) string { var o strings.Builder for _, c := range v { if c == ' ' \|\| c == '\t' { o.WriteRune(c) } else { break } } return o.String() } // generateDoc will generate the proper doc string for html encoded or plain text doc entries. func generateDoc(htmlSrc string) string { tokenizer := xml.NewDecoder(strings.NewReader(htmlSrc)) tokenizer.Strict = false tokenizer.AutoClose = xml.HTMLAutoClose tokenizer.Entity = xml.HTMLEntity // Some service docstrings are hopelessly malformed. Rather than throwing // up our hands, the converter will map over as much as it can. If it // returns an error, we stop there and go with whatever it was able to // produce. var builder strings.Builder encodeHTMLToText(&builder, tokenizer) return wrap(strings.Trim(builder.String(), "\n"), 72) } type stringWriter interface { Write([]byte) (int, error) WriteByte(byte) error WriteRune(rune) (int, error) WriteString(string) (int, error) } func encodeHTMLToText(w stringWriter, z xml.Decoder) error { encoder := newHTMLTokenEncoder(w) defer encoder.Flush() for { tt, err := z.Token() if err == io.EOF { return nil } if err != nil { return err } if err := encoder.Encode(tt); err != nil { return err } } } type htmlTokenHandler interface { OnStartTagToken(xml.StartElement) htmlTokenHandler OnEndTagToken(xml.Token, bool) OnSelfClosingTagToken(xml.Token) OnTextTagToken(xml.CharData) } type htmlTokenEncoder struct { w stringWriter depth int handlers []tokenHandlerItem baseHandler tokenHandlerItem } type tokenHandlerItem struct { handler htmlTokenHandler depth int } func newHTMLTokenEncoder(w stringWriter) htmlTokenEncoder { baseHandler := newBlockTokenHandler(w) baseHandler.rootBlock = true return &htmlTokenEncoder{ w: w, baseHandler: tokenHandlerItem{ handler: baseHandler, }, } } func (e htmlTokenEncoder) Flush() error { e.baseHandler.handler.OnEndTagToken(xml.CharData([]byte{}), true) return nil } func (e htmlTokenEncoder) Encode(token xml.Token) error { h := e.baseHandler if len(e.handlers) != 0 { h = e.handlers[len(e.handlers)-1] } switch v := token.(type) { case xml.StartElement: e.depth++ next := h.handler.OnStartTagToken(v) if next != nil { e.handlers = append(e.handlers, tokenHandlerItem{ handler: next, depth: e.depth, }) } case xml.EndElement: handlerBlockClosing := e.depth == h.depth h.handler.OnEndTagToken(token, handlerBlockClosing) // Remove all but the root handler as the handler is no longer needed. if handlerBlockClosing && len(e.handlers) != 0 { e.handlers = e.handlers[:len(e.handlers)-1] } e.depth-- if e.depth < 0 { log.Printf("ignoring unexpected closing tag, %v", token) e.depth = 0 } case xml.CharData: h.handler.OnTextTagToken(v) } return nil } type baseTokenHandler struct { w stringWriter } func (e baseTokenHandler) OnStartTagToken(token xml.StartElement) htmlTokenHandler { return nil } func (e baseTokenHandler) OnEndTagToken(token xml.Token, blockClosing bool) {} func (e baseTokenHandler) OnSelfClosingTagToken(token xml.Token) {} func (e baseTokenHandler) OnTextTagToken(token xml.CharData) { e.w.WriteString(string(token)) } type blockTokenHandler struct { baseTokenHandler rootBlock bool origWriter stringWriter strBuilder strings.Builder started bool newlineBeforeNextBlock bool } func newBlockTokenHandler(w stringWriter) blockTokenHandler { strBuilder := &strings.Builder{} return &blockTokenHandler{ origWriter: w, strBuilder: strBuilder, baseTokenHandler: baseTokenHandler{ w: strBuilder, }, } } func (e blockTokenHandler) OnStartTagToken(token xml.StartElement) htmlTokenHandler { e.started = true if e.newlineBeforeNextBlock { e.w.WriteString("\n") e.newlineBeforeNextBlock = false } switch token.Name.Local { case "a": return newLinkTokenHandler(e.w, token) case "ul": e.w.WriteString("\n") e.newlineBeforeNextBlock = true return newListTokenHandler(e.w) case "div", "dt", "p", "h1", "h2", "h3", "h4", "h5", "h6": e.w.WriteString("\n") e.newlineBeforeNextBlock = true return newBlockTokenHandler(e.w) case "pre", "code": if e.rootBlock { e.w.WriteString("\n") e.w.WriteString(indent) e.newlineBeforeNextBlock = true } return newBlockTokenHandler(e.w) } return nil } func (e blockTokenHandler) OnEndTagToken(token xml.Token, blockClosing bool) { if !blockClosing { return } e.origWriter.WriteString(e.strBuilder.String()) if e.newlineBeforeNextBlock { e.origWriter.WriteString("\n") e.newlineBeforeNextBlock = false } e.strBuilder.Reset() } func (e blockTokenHandler) OnTextTagToken(token xml.CharData) { if e.newlineBeforeNextBlock { e.w.WriteString("\n") e.newlineBeforeNextBlock = false } if !e.started { token = xml.CharData(strings.TrimLeft(string(token), " \t\n")) } if len(token) != 0 { e.started = true } e.baseTokenHandler.OnTextTagToken(token) } type linkTokenHandler struct { baseTokenHandler linkToken xml.StartElement } func newLinkTokenHandler(w stringWriter, token xml.StartElement) linkTokenHandler { return &linkTokenHandler{ baseTokenHandler: baseTokenHandler{ w: w, }, linkToken: token, } } func (e linkTokenHandler) OnEndTagToken(token xml.Token, blockClosing bool) { if !blockClosing { return } if href, ok := getHTMLTokenAttr(e.linkToken.Attr, "href"); ok && len(href) != 0 { fmt.Fprintf(e.w, " (%s)", strings.TrimSpace(href)) } } type listTokenHandler struct { baseTokenHandler items int } func newListTokenHandler(w stringWriter) listTokenHandler { return &listTokenHandler{ baseTokenHandler: baseTokenHandler{ w: w, }, } } func (e listTokenHandler) OnStartTagToken(token xml.StartElement) htmlTokenHandler { switch token.Name.Local { case "li": if e.items >= 1 { e.w.WriteString("\n\n") } e.items++ return newListItemTokenHandler(e.w) } return nil } func (e listTokenHandler) OnTextTagToken(token xml.CharData) { // Squash whitespace between list and items } type listItemTokenHandler struct { baseTokenHandler origWriter stringWriter strBuilder strings.Builder } func newListItemTokenHandler(w stringWriter) listItemTokenHandler { strBuilder := &strings.Builder{} return &listItemTokenHandler{ origWriter: w, strBuilder: strBuilder, baseTokenHandler: baseTokenHandler{ w: strBuilder, }, } } func (e listItemTokenHandler) OnStartTagToken(token xml.StartElement) htmlTokenHandler { switch token.Name.Local { case "p": return newBlockTokenHandler(e.w) } return nil } func (e listItemTokenHandler) OnEndTagToken(token xml.Token, blockClosing bool) { if !blockClosing { return } e.origWriter.WriteString(indent + " ") e.origWriter.WriteString(strings.TrimSpace(e.strBuilder.String())) } type trimSpaceTokenHandler struct { baseTokenHandler origWriter stringWriter strBuilder strings.Builder } func newTrimSpaceTokenHandler(w stringWriter) trimSpaceTokenHandler { strBuilder := &strings.Builder{} return &trimSpaceTokenHandler{ origWriter: w, strBuilder: strBuilder, baseTokenHandler: baseTokenHandler{ w: strBuilder, }, } } func (e *trimSpaceTokenHandler) OnEndTagToken(token xml.Token, blockClosing bool) { if !blockClosing { return } e.origWriter.WriteString(strings.TrimSpace(e.strBuilder.String())) } func getHTMLTokenAttr(attr []xml.Attr, name string) (string, bool) { for _, a := range attr { if strings.EqualFold(a.Name.Local, name) { return a.Value, true } } return "", false } func AppendDocstring(base, toAdd string) string { if base != "" { base += "\n//\n" } return base + docstring(toAdd) }	11.98 KB	2025-05-25 12:27
📄 docstring_test.go //go:build go1.8 && codegen // +build go1.8,codegen package api import ( "testing" ) func TestDocstring(t testing.T) { cases := map[string]struct { In string Expect string }{ "non HTML": { In: "Testing 1 2 3", Expect: "// Testing 1 2 3", }, "link": { In: `<a href="https://example.com">a link</a>`, Expect: "// a link (https://example.com)", }, "link with space": { In: `<a href=" https://example.com">a link</a>`, Expect: "// a link (https://example.com)", }, "list HTML 01": { In: "<ul><li>Testing 1 2 3</li> <li>FooBar</li></ul>", Expect: "// Testing 1 2 3\n// \n// * FooBar", }, "list HTML 02": { In: "<ul> <li>Testing 1 2 3</li> <li>FooBar</li> </ul>", Expect: "// * Testing 1 2 3\n// \n// * FooBar", }, "list HTML leading spaces": { In: " <ul> <li>Testing 1 2 3</li> <li>FooBar</li> </ul>", Expect: "// * Testing 1 2 3\n// \n// * FooBar", }, "list HTML paragraph": { In: "<ul> <li> <p>Testing 1 2 3</p> </li><li> <p>FooBar</p></li></ul>", Expect: "// * Testing 1 2 3\n// \n// * FooBar", }, "inline code HTML": { In: "<ul> <li><code>Testing</code>: 1 2 3</li> <li>FooBar</li> </ul>", Expect: "// * Testing: 1 2 3\n// \n// * FooBar", }, "complex list paragraph": { In: "<ul> <li><p><code>FOO</code> Bar</p></li><li><p><code>Xyz</code> ABC</p></li></ul>", Expect: "// * FOO Bar\n// \n// * Xyz ABC", }, "inline code in paragraph": { In: "<p><code>Testing</code>: 1 2 3</p>", Expect: "// Testing: 1 2 3", }, "root pre": { In: "<pre><code>Testing</code></pre>", Expect: "// Testing", }, "paragraph": { In: "<p>Testing 1 2 3</p>", Expect: "// Testing 1 2 3", }, "wrap lines": { In: "<span data-target-type=\"operation\" data-service=\"secretsmanager\" data-target=\"CreateSecret\">CreateSecret</span> <span data-target-type=\"structure\" data-service=\"secretsmanager\" data-target=\"SecretListEntry\">SecretListEntry</span> <span data-target-type=\"structure\" data-service=\"secretsmanager\" data-target=\"CreateSecret$SecretName\">SecretName</span> <span data-target-type=\"structure\" data-service=\"secretsmanager\" data-target=\"SecretListEntry$KmsKeyId\">KmsKeyId</span>", Expect: "// CreateSecret SecretListEntry SecretName KmsKeyId", }, "links with spaces": { In: "<p> Deletes the replication configuration from the bucket. For information about replication configuration, see <a href=\" https://docs.aws.amazon.com/AmazonS3/latest/dev/crr.html\">Cross-Region Replication (CRR)</a> in the <i>Amazon S3 Developer Guide</i>. </p>", Expect: "// Deletes the replication configuration from the bucket. For information about\n// replication configuration, see Cross-Region Replication (CRR) (https://docs.aws.amazon.com/AmazonS3/latest/dev/crr.html)\n// in the Amazon S3 Developer Guide.", }, "unexpected closing tag": { In: "<p>Some cool text</p></p>", Expect: "// Some cool text", }, } for name, c := range cases { t.Run(name, func(t testing.T) { actual := docstring(c.In) if e, a := c.Expect, actual; e != a { t.Errorf("expect %q, got %q", e, a) } }) } } func TestApiDocumentation_missingShapes(t testing.T) { docs := apiDocumentation{ Service: "some service documentation", Operations: map[string]string{ "OperationOne": "some operation documentation", "OperationTwo": "some more operation documentation", }, Shapes: map[string]shapeDocumentation{ "ShapeOne": { Base: "some shape documentation", }, "ShapeTwo": { Base: "some more shape documentation", Refs: map[string]string{ "ShapeOne$shapeTwo": "shape ref document", }, }, }, } api := API{ Operations: map[string]Operation{ "OperationOne": {}, }, Shapes: map[string]Shape{ "ShapeOne": { Type: "structure", MemberRefs: map[string]*ShapeRef{}, }, }, } if err := docs.setup(&api); err != nil { t.Fatalf("expect no error, got %v", err) } if _, ok := api.Operations["OperationTwo"]; ok { t.Errorf("expect operation shape to not be added from document model") } if _, ok := api.Shapes["ShapeTwo"]; ok { t.Errorf("expect shape to not be added from document model") } if _, ok := api.Shapes["ShapeOne"].MemberRefs["shapeTwo"]; ok { t.Errorf("expect shape to not be added from document model") } }	4.34 KB	2025-05-25 12:27
📄 endpoint_arn.go package api import "text/template" const endpointARNShapeTmplDef = ` {{- define "endpointARNShapeTmpl" }} {{ range $_, $name := $.MemberNames -}} {{ $elem := index $.MemberRefs $name -}} {{ if $elem.EndpointARN -}} func (s {{ $.ShapeName }}) getEndpointARN() (arn.Resource, error) { if s.{{ $name }} == nil { return nil, fmt.Errorf("member {{ $name }} is nil") } return parseEndpointARN(s.{{ $name }}) } func (s {{ $.ShapeName }}) hasEndpointARN() bool { if s.{{ $name }} == nil { return false } return arn.IsARN(s.{{ $name }}) } // updateArnableField updates the value of the input field that // takes an ARN as an input. This method is useful to backfill // the parsed resource name from ARN into the input member. // It returns a pointer to a modified copy of input and an error. // Note that original input is not modified. func (s {{ $.ShapeName }}) updateArnableField(v string) (interface{}, error) { if s.{{ $name }} == nil { return nil, fmt.Errorf("member {{ $name }} is nil") } s.{{ $name }} = aws.String(v) return &s, nil } {{ end -}} {{ end }} {{ end }} ` var endpointARNShapeTmpl = template.Must( template.New("endpointARNShapeTmpl"). Parse(endpointARNShapeTmplDef), ) const outpostIDShapeTmplDef = ` {{- define "outpostIDShapeTmpl" }} {{ range $_, $name := $.MemberNames -}} {{ $elem := index $.MemberRefs $name -}} {{ if $elem.OutpostIDMember -}} func (s {{ $.ShapeName }}) getOutpostID() (string, error) { if s.{{ $name }} == nil { return "", fmt.Errorf("member {{ $name }} is nil") } return s.{{ $name }}, nil } func (s {{ $.ShapeName }}) hasOutpostID() bool { if s.{{ $name }} == nil { return false } return true } {{ end -}} {{ end }} {{ end }} ` var outpostIDShapeTmpl = template.Must( template.New("outpostIDShapeTmpl"). Parse(outpostIDShapeTmplDef), ) const accountIDWithARNShapeTmplDef = ` {{- define "accountIDWithARNShapeTmpl" }} {{ range $_, $name := $.MemberNames -}} {{ $elem := index $.MemberRefs $name -}} {{ if $elem.AccountIDMemberWithARN -}} {{ $FunctionName := $name }} {{ if eq $name "AccountId" }} {{ $FunctionName = "AccountID" }} {{ end }} // update{{ $FunctionName }} returns a pointer to a modified copy of input, // if account id is not provided, we update the account id in modified input // if account id is provided, but doesn't match with the one in ARN, we throw an error // if account id is not updated, we return nil. Note that original input is not modified. func (s {{ $.ShapeName }}) update{{ $FunctionName }}(accountId string) (interface{}, error) { if s.{{ $name }} == nil { s.{{ $name }} = aws.String(accountId) return &s, nil } else if s.{{ $name }} != accountId { return &s, fmt.Errorf("Account ID mismatch, the Account ID cannot be specified in an ARN and in the accountId field") } return nil, nil } {{ end -}} {{ end }} {{ end }} ` var accountIDWithARNShapeTmpl = template.Must( template.New("accountIDWithARNShapeTmpl"). Parse(accountIDWithARNShapeTmplDef), )	3.03 KB	2025-05-25 12:27
📄 endpoint_trait.go //go:build codegen // +build codegen package api import ( "fmt" "text/template" ) func setupEndpointHostPrefix(op Operation) { op.API.AddSDKImport("private/protocol") buildHandler := fmt.Sprintf("protocol.NewHostPrefixHandler(%q, ", op.Endpoint.HostPrefix) if op.InputRef.Shape.HasHostLabelMembers() { buildHandler += "input.hostLabels" } else { buildHandler += "nil" } buildHandler += ")" op.CustomBuildHandlers = append(op.CustomBuildHandlers, buildHandler, "protocol.ValidateEndpointHostHandler", ) } // HasHostLabelMembers returns true if the shape contains any members which are // decorated with the hostLabel trait. func (s Shape) HasHostLabelMembers() bool { for _, ref := range s.MemberRefs { if ref.HostLabel { return true } } return false } var hostLabelsShapeTmpl = template.Must( template.New("hostLabelsShapeTmpl"). Parse(hostLabelsShapeTmplDef), ) const hostLabelsShapeTmplDef = ` {{- define "hostLabelsShapeTmpl" }} func (s *{{ $.ShapeName }}) hostLabels() map[string]string { return map[string]string{ {{- range $name, $ref := $.MemberRefs }} {{- if $ref.HostLabel }} "{{ $name }}": aws.StringValue(s.{{ $name }}), {{- end }} {{- end }} } } {{- end }} `	1.2 KB	2025-05-25 12:27
📄 eventstream.go //go:build codegen // +build codegen package api import ( "bytes" "fmt" "text/template" ) // EventStreamAPI provides details about the event stream async API and // associated EventStream shapes. type EventStreamAPI struct { API API Operation Operation Name string InputStream EventStream OutputStream EventStream RequireHTTP2 bool // The eventstream generated code was generated with an older model that // does not scale with bi-directional models. This drives the need to // expose the output shape's event stream member as an exported member. Legacy bool } func (es EventStreamAPI) StreamInputEventTypeGetterName() string { return "eventTypeFor" + es.Name + "InputEvent" } func (es EventStreamAPI) StreamOutputUnmarshalerForEventName() string { return "eventTypeFor" + es.Name + "OutputEvent" } // EventStream represents a single eventstream group (input/output) and the // modeled events that are known for the stream. type EventStream struct { Name string Shape Shape Events []Event Exceptions []Event } func (es EventStream) EventGroupName() string { return es.Name + "Event" } func (es EventStream) StreamWriterAPIName() string { return es.Name + "Writer" } func (es EventStream) StreamWriterImplName() string { return "write" + es.Name } func (es EventStream) StreamEventTypeGetterName() string { return "eventTypeFor" + es.Name + "Event" } func (es EventStream) StreamReaderAPIName() string { return es.Name + "Reader" } func (es EventStream) StreamReaderImplName() string { return "read" + es.Name } func (es EventStream) StreamReaderImplConstructorName() string { return "newRead" + es.Name } func (es EventStream) StreamUnmarshalerForEventName() string { return "unmarshalerFor" + es.Name + "Event" } func (es EventStream) StreamUnknownEventName() string { return es.Name + "UnknownEvent" } // Event is a single EventStream event that can be sent or received in an // EventStream. type Event struct { Name string Shape Shape For EventStream Private bool } // ShapeDoc returns the docstring for the EventStream API. func (esAPI EventStreamAPI) ShapeDoc() string { tmpl := template.Must(template.New("eventStreamShapeDoc").Parse(` {{- $.Name }} provides handling of EventStreams for the {{ $.Operation.ExportedName }} API. {{- if $.OutputStream }} Use this type to receive {{ $.OutputStream.Name }} events. The events can be read from the stream. The events that can be received are: {{- range $_, $event := $.OutputStream.Events }} {{ $event.Shape.ShapeName }} {{- end }} {{- end }} {{- if $.InputStream }} Use this type to send {{ $.InputStream.Name }} events. The events can be written to the stream. The events that can be sent are: {{ range $_, $event := $.InputStream.Events -}} * {{ $event.Shape.ShapeName }} {{- end }} {{- end }}`)) var w bytes.Buffer if err := tmpl.Execute(&w, esAPI); err != nil { panic(fmt.Sprintf("failed to generate eventstream shape template for %v, %v", esAPI.Operation.ExportedName, err)) } return commentify(w.String()) } func hasEventStream(topShape Shape) bool { for _, ref := range topShape.MemberRefs { if ref.Shape.IsEventStream { return true } } return false } func eventStreamAPIShapeRefDoc(refName string) string { return commentify(fmt.Sprintf("Use %s to use the API's stream.", refName)) } func (a API) setupEventStreams() error { streams := EventStreams{} for opName, op := range a.Operations { inputRef := getEventStreamMember(op.InputRef.Shape) outputRef := getEventStreamMember(op.OutputRef.Shape) if inputRef == nil && outputRef == nil { continue } if inputRef != nil && outputRef == nil { return fmt.Errorf("event stream input only stream not supported for protocol %s, %s, %v", a.NiceName(), opName, a.Metadata.Protocol) } switch a.Metadata.Protocol { case `rest-json`, `rest-xml`, `json`: default: return UnsupportedAPIModelError{ Err: fmt.Errorf("EventStream not supported for protocol %s, %s, %v", a.NiceName(), opName, a.Metadata.Protocol), } } var inputStream EventStream if inputRef != nil { inputStream = streams.GetStream(op.InputRef.Shape, inputRef.Shape) inputStream.Shape.IsInputEventStream = true } var outputStream EventStream if outputRef != nil { outputStream = streams.GetStream(op.OutputRef.Shape, outputRef.Shape) outputStream.Shape.IsOutputEventStream = true } requireHTTP2 := op.API.Metadata.ProtocolSettings.HTTP2 == "eventstream" && inputStream != nil && outputStream != nil a.HasEventStream = true op.EventStreamAPI = &EventStreamAPI{ API: a, Operation: op, Name: op.ExportedName + "EventStream", InputStream: inputStream, OutputStream: outputStream, Legacy: isLegacyEventStream(op), RequireHTTP2: requireHTTP2, } op.OutputRef.Shape.OutputEventStreamAPI = op.EventStreamAPI if s, ok := a.Shapes[op.EventStreamAPI.Name]; ok { newName := op.EventStreamAPI.Name + "Data" if _, ok := a.Shapes[newName]; ok { panic(fmt.Sprintf( "%s: attempting to rename %s to %s, but shape with that name already exists", a.NiceName(), op.EventStreamAPI.Name, newName)) } s.Rename(newName) } } return nil } // EventStreams is a map of streams for the API shared across all operations. // Ensurs that no stream is duplicated. type EventStreams map[Shape]EventStream // GetStream returns an EventStream for the operations top level shape, and // member reference to the stream shape. func (es EventStreams) GetStream(topShape Shape, streamShape Shape) EventStream { var stream EventStream if v, ok := (es)[streamShape]; ok { stream = v } else { stream = setupEventStream(streamShape) (es)[streamShape] = stream } if topShape.API.Metadata.Protocol == "json" { if topShape.EventFor == nil { topShape.EventFor = map[string]EventStream{} } topShape.EventFor[stream.Name] = stream } return stream } var legacyEventStream = map[string]map[string]struct{}{ "s3": { "SelectObjectContent": struct{}{}, }, "kinesis": { "SubscribeToShard": struct{}{}, }, } func isLegacyEventStream(op Operation) bool { if s, ok := legacyEventStream[op.API.PackageName()]; ok { if _, ok = s[op.ExportedName]; ok { return true } } return false } func (e EventStreamAPI) OutputMemberName() string { if e.Legacy { return "EventStream" } return "eventStream" } func getEventStreamMember(topShape Shape) ShapeRef { for _, ref := range topShape.MemberRefs { if !ref.Shape.IsEventStream { continue } return ref } return nil } func setupEventStream(s Shape) EventStream { eventStream := &EventStream{ Name: s.ShapeName, Shape: s, } s.EventStream = eventStream for _, eventRefName := range s.MemberNames() { eventRef := s.MemberRefs[eventRefName] if !(eventRef.Shape.IsEvent \|\| eventRef.Shape.Exception) { panic(fmt.Sprintf("unexpected non-event member reference %s.%s", s.ShapeName, eventRefName)) } updateEventPayloadRef(eventRef.Shape) if eventRef.Shape.EventFor == nil { eventRef.Shape.EventFor = map[string]EventStream{} } eventRef.Shape.EventFor[eventStream.Name] = eventStream eventName := eventRefName if v := eventRef.LocationName; v != "" { eventName = v } // Exceptions and events are two different lists to allow the SDK // to easily generate code with the two handled differently. event := &Event{ Name: eventName, Shape: eventRef.Shape, For: eventStream, } if eventRef.Shape.Exception { eventStream.Exceptions = append(eventStream.Exceptions, event) } else { eventStream.Events = append(eventStream.Events, event) } } return eventStream } func updateEventPayloadRef(parent *Shape) { refName := parent.PayloadRefName() if len(refName) == 0 { return } payloadRef := parent.MemberRefs[refName] if payloadRef.Shape.Type == "blob" { return } if len(payloadRef.LocationName) != 0 { return } payloadRef.LocationName = refName }	7.89 KB	2025-05-25 12:27
📄 eventstream_tmpl.go //go:build codegen // +build codegen package api import ( "fmt" "io" "strings" "text/template" ) func renderEventStreamAPI(w io.Writer, op Operation) error { // Imports needed by the EventStream APIs. op.API.AddImport("fmt") op.API.AddImport("bytes") op.API.AddImport("io") op.API.AddImport("time") op.API.AddSDKImport("aws") op.API.AddSDKImport("aws/awserr") op.API.AddSDKImport("aws/request") op.API.AddSDKImport("private/protocol/eventstream") op.API.AddSDKImport("private/protocol/eventstream/eventstreamapi") // usages of these imports are conditional - generate a compile-only // reference to avoid potential unused imports: // - awserr is only used for input streams or json protocols // - time is only used for input streams or if an event payload has a // timestamp field w.Write([]byte(` var _ awserr.Error var _ time.Time `)) return eventStreamAPITmpl.Execute(w, op) } // Template for an EventStream API Shape that will provide read/writing events // across the EventStream. This is a special shape that's only public members // are the Events channel and a Close and Err method. // // Executed in the context of a Shape. var eventStreamAPITmpl = template.Must( template.New("eventStreamAPITmplDef"). Funcs(template.FuncMap{ "unexported": func(v string) string { return strings.ToLower(string(v[0])) + v[1:] }, }). Parse(eventStreamAPITmplDef), ) const eventStreamAPITmplDef = ` {{- $esapi := $.EventStreamAPI }} {{- $outputStream := $esapi.OutputStream }} {{- $inputStream := $esapi.InputStream }} // {{ $esapi.Name }} provides the event stream handling for the {{ $.ExportedName }}. // // For testing and mocking the event stream this type should be initialized via // the New{{ $esapi.Name }} constructor function. Using the functional options // to pass in nested mock behavior. type {{ $esapi.Name }} struct { {{- if $inputStream }} // Writer is the EventStream writer for the {{ $inputStream.Name }} // events. This value is automatically set by the SDK when the API call is made // Use this member when unit testing your code with the SDK to mock out the // EventStream Writer. // // Must not be nil. Writer {{ $inputStream.StreamWriterAPIName }} inputWriter io.WriteCloser {{- if eq .API.Metadata.Protocol "json" }} input {{ $.InputRef.GoType }} {{- end }} {{- end }} {{- if $outputStream }} // Reader is the EventStream reader for the {{ $outputStream.Name }} // events. This value is automatically set by the SDK when the API call is made // Use this member when unit testing your code with the SDK to mock out the // EventStream Reader. // // Must not be nil. Reader {{ $outputStream.StreamReaderAPIName }} outputReader io.ReadCloser {{- if eq .API.Metadata.Protocol "json" }} output {{ $.OutputRef.GoType }} {{- end }} {{- end }} {{- if $esapi.Legacy }} // StreamCloser is the io.Closer for the EventStream connection. For HTTP // EventStream this is the response Body. The stream will be closed when // the Close method of the EventStream is called. StreamCloser io.Closer {{- end }} done chan struct{} closeOnce sync.Once err eventstreamapi.OnceError } // New{{ $esapi.Name }} initializes an {{ $esapi.Name }}. // This function should only be used for testing and mocking the {{ $esapi.Name }} // stream within your application. {{- if $inputStream }} // // The Writer member must be set before writing events to the stream. {{- end }} {{- if $outputStream }} // // The Reader member must be set before reading events from the stream. {{- end }} {{- if $esapi.Legacy }} // // The StreamCloser member should be set to the underlying io.Closer, // (e.g. http.Response.Body), that will be closed when the stream Close method // is called. {{- end }} // // es := New{{ $esapi.Name }}(func(o {{ $esapi.Name}}){ {{- if $inputStream }} // es.Writer = myMockStreamWriter {{- end }} {{- if $outputStream }} // es.Reader = myMockStreamReader {{- end }} {{- if $esapi.Legacy }} // es.StreamCloser = myMockStreamCloser {{- end }} // }) func New{{ $esapi.Name }}(opts ...func({{ $esapi.Name}})) {{ $esapi.Name }} { es := &{{ $esapi.Name }} { done: make(chan struct{}), err: eventstreamapi.NewOnceError(), } for _, fn := range opts { fn(es) } return es } {{- if $esapi.Legacy }} func (es {{ $esapi.Name }}) setStreamCloser(r request.Request) { es.StreamCloser = r.HTTPResponse.Body } {{- end }} func (es {{ $esapi.Name }}) runOnStreamPartClose(r request.Request) { if es.done == nil { return } go es.waitStreamPartClose() } func (es {{ $esapi.Name }}) waitStreamPartClose() { {{- if $inputStream }} var inputErrCh <-chan struct{} if v, ok := es.Writer.(interface{ErrorSet() <-chan struct{}}); ok { inputErrCh = v.ErrorSet() } {{- end }} {{- if $outputStream }} var outputErrCh <-chan struct{} if v, ok := es.Reader.(interface{ErrorSet() <-chan struct{}}); ok { outputErrCh = v.ErrorSet() } var outputClosedCh <- chan struct{} if v, ok := es.Reader.(interface{Closed() <-chan struct{}}); ok { outputClosedCh = v.Closed() } {{- end }} select { case <-es.done: {{- if $inputStream }} case <-inputErrCh: es.err.SetError(es.Writer.Err()) es.Close() {{- end }} {{- if $outputStream }} case <-outputErrCh: es.err.SetError(es.Reader.Err()) es.Close() case <-outputClosedCh: if err := es.Reader.Err(); err != nil { es.err.SetError(es.Reader.Err()) } es.Close() {{- end }} } } {{- if $inputStream }} {{- if eq .API.Metadata.Protocol "json" }} func {{ $esapi.StreamInputEventTypeGetterName }}(event {{ $inputStream.EventGroupName }}) (string, error) { if _, ok := event.({{ $.InputRef.GoType }}); ok { return "initial-request", nil } return {{ $inputStream.StreamEventTypeGetterName }}(event) } {{- end }} func (es {{ $esapi.Name }}) setupInputPipe(r request.Request) { inputReader, inputWriter := io.Pipe() r.SetStreamingBody(inputReader) es.inputWriter = inputWriter } // Closes the input-pipe writer func (es {{ $esapi.Name }}) closeInputPipe() error { if es.inputWriter != nil { return es.inputWriter.Close() } return nil } // Send writes the event to the stream blocking until the event is written. // Returns an error if the event was not written. // // These events are: // {{ range $_, $event := $inputStream.Events }} // {{ $event.Shape.ShapeName }} {{- end }} func (es {{ $esapi.Name }}) Send(ctx aws.Context, event {{ $inputStream.EventGroupName }}) error { return es.Writer.Send(ctx, event) } func (es {{ $esapi.Name }}) runInputStream(r request.Request) { var opts []func(eventstream.Encoder) if r.Config.Logger != nil && r.Config.LogLevel.Matches(aws.LogDebugWithEventStreamBody) { opts = append(opts, eventstream.EncodeWithLogger(r.Config.Logger)) } var encoder eventstreamapi.Encoder = eventstream.NewEncoder(es.inputWriter, opts...) var closer aws.MultiCloser {{- if $.ShouldSignRequestBody }} {{- $_ := $.API.AddSDKImport "aws/signer/v4" }} sigSeed, err := v4.GetSignedRequestSignature(r.HTTPRequest) if err != nil { r.Error = awserr.New(request.ErrCodeSerialization, "unable to get initial request's signature", err) return } signer := eventstreamapi.NewSignEncoder( v4.NewStreamSigner(r.ClientInfo.SigningRegion, r.ClientInfo.SigningName, sigSeed, r.Config.Credentials), encoder, ) encoder = signer closer = append(closer, signer) {{- end }} closer = append(closer, es.inputWriter) eventWriter := eventstreamapi.NewEventWriter(encoder, protocol.HandlerPayloadMarshal{ Marshalers: r.Handlers.BuildStream, }, {{- if eq .API.Metadata.Protocol "json" }} {{ $esapi.StreamInputEventTypeGetterName }}, {{- else }} {{ $inputStream.StreamEventTypeGetterName }}, {{- end }} ) es.Writer = &{{ $inputStream.StreamWriterImplName }}{ StreamWriter: eventstreamapi.NewStreamWriter(eventWriter, closer), } } {{- if eq .API.Metadata.Protocol "json" }} func (es {{ $esapi.Name }}) sendInitialEvent(r request.Request) { if err := es.Send(es.input); err != nil { r.Error = err } } {{- end }} {{- end }} {{- if $outputStream }} {{- if eq .API.Metadata.Protocol "json" }} type {{ $esapi.StreamOutputUnmarshalerForEventName }} struct { unmarshalerForEvent func(string) (eventstreamapi.Unmarshaler, error) output {{ $.OutputRef.GoType }} } func (e {{ $esapi.StreamOutputUnmarshalerForEventName }}) UnmarshalerForEventName(eventType string) (eventstreamapi.Unmarshaler, error) { if eventType == "initial-response" { return e.output, nil } return e.unmarshalerForEvent(eventType) } {{- end }} // Events returns a channel to read events from. // // These events are: // {{ range $_, $event := $outputStream.Events }} // * {{ $event.Shape.ShapeName }} {{- end }} // * {{ $outputStream.StreamUnknownEventName }} func (es {{ $esapi.Name }}) Events() <-chan {{ $outputStream.EventGroupName }} { return es.Reader.Events() } func (es {{ $esapi.Name }}) runOutputStream(r request.Request) { var opts []func(eventstream.Decoder) if r.Config.Logger != nil && r.Config.LogLevel.Matches(aws.LogDebugWithEventStreamBody) { opts = append(opts, eventstream.DecodeWithLogger(r.Config.Logger)) } unmarshalerForEvent := {{ $outputStream.StreamUnmarshalerForEventName }}{ metadata: protocol.ResponseMetadata{ StatusCode: r.HTTPResponse.StatusCode, RequestID: r.RequestID, }, }.UnmarshalerForEventName {{- if eq .API.Metadata.Protocol "json" }} unmarshalerForEvent = {{ $esapi.StreamOutputUnmarshalerForEventName }}{ unmarshalerForEvent: unmarshalerForEvent, output: es.output, }.UnmarshalerForEventName {{- end }} decoder := eventstream.NewDecoder(r.HTTPResponse.Body, opts...) eventReader := eventstreamapi.NewEventReader(decoder, protocol.HandlerPayloadUnmarshal{ Unmarshalers: r.Handlers.UnmarshalStream, }, unmarshalerForEvent, ) es.outputReader = r.HTTPResponse.Body es.Reader = {{ $outputStream.StreamReaderImplConstructorName }}(eventReader) } {{- if eq .API.Metadata.Protocol "json" }} func (es {{ $esapi.Name }}) recvInitialEvent(r request.Request) { // Wait for the initial response event, which must be the first // event to be received from the API. select { case event, ok := <- es.Events(): if !ok { return } v, ok := event.({{ $.OutputRef.GoType }}) if !ok \|\| v == nil { r.Error = awserr.New( request.ErrCodeSerialization, fmt.Sprintf("invalid event, %T, expect %T, %v", event, ({{ $.OutputRef.GoType }})(nil), v), nil, ) return } es.output = v es.output.{{ $.EventStreamAPI.OutputMemberName }} = es } } {{- end }} {{- end }} // Close closes the stream. This will also cause the stream to be closed. // Close must be called when done using the stream API. Not calling Close // may result in resource leaks. {{- if $inputStream }} // // Will close the underlying EventStream writer, and no more events can be // sent. {{- end }} {{- if $outputStream }} // // You can use the closing of the Reader's Events channel to terminate your // application's read from the API's stream. {{- end }} // func (es {{ $esapi.Name }}) Close() (err error) { es.closeOnce.Do(es.safeClose) return es.Err() } func (es {{ $esapi.Name }}) safeClose() { if es.done != nil { close(es.done) } {{- if $inputStream }} t := time.NewTicker(time.Second) defer t.Stop() writeCloseDone := make(chan error) go func() { if err := es.Writer.Close(); err != nil { es.err.SetError(err) } close(writeCloseDone) }() select { case <-t.C: case <-writeCloseDone: } if err := es.closeInputPipe(); err != nil { es.err.SetError(err) } {{- end }} {{- if $outputStream }} es.Reader.Close() if es.outputReader != nil { es.outputReader.Close() } {{- end }} {{- if $esapi.Legacy }} es.StreamCloser.Close() {{- end }} } // Err returns any error that occurred while reading or writing EventStream // Events from the service API's response. Returns nil if there were no errors. func (es {{ $esapi.Name }}) Err() error { if err := es.err.Err(); err != nil { return err } {{- if $inputStream }} if err := es.Writer.Err(); err != nil { return err } {{- end }} {{- if $outputStream }} if err := es.Reader.Err(); err != nil { return err } {{- end }} return nil } ` func renderEventStreamShape(w io.Writer, s Shape) error { // Imports needed by the EventStream APIs. s.API.AddImport("fmt") s.API.AddImport("bytes") s.API.AddImport("io") s.API.AddImport("sync") s.API.AddSDKImport("aws") s.API.AddSDKImport("aws/awserr") s.API.AddSDKImport("private/protocol/eventstream") s.API.AddSDKImport("private/protocol/eventstream/eventstreamapi") return eventStreamShapeTmpl.Execute(w, s) } var eventStreamShapeTmpl = func() template.Template { t := template.Must( template.New("eventStreamShapeTmplDef"). Parse(eventStreamShapeTmplDef), ) template.Must( t.AddParseTree( "eventStreamShapeWriterTmpl", eventStreamShapeWriterTmpl.Tree), ) template.Must( t.AddParseTree( "eventStreamShapeReaderTmpl", eventStreamShapeReaderTmpl.Tree), ) return t }() const eventStreamShapeTmplDef = ` {{- $eventStream := $.EventStream }} {{- $eventStreamEventGroup := printf "%sEvent" $eventStream.Name }} // {{ $eventStreamEventGroup }} groups together all EventStream // events writes for {{ $eventStream.Name }}. // // These events are: // {{ range $_, $event := $eventStream.Events }} // {{ $event.Shape.ShapeName }} {{- end }} type {{ $eventStreamEventGroup }} interface { event{{ $eventStream.Name }}() eventstreamapi.Marshaler eventstreamapi.Unmarshaler } {{- if $.IsInputEventStream }} {{- template "eventStreamShapeWriterTmpl" $ }} {{- end }} {{- if $.IsOutputEventStream }} {{- template "eventStreamShapeReaderTmpl" $ }} {{- end }} ` // EventStreamHeaderTypeMap provides the mapping of a EventStream Header's // Value type to the shape reference's member type. type EventStreamHeaderTypeMap struct { Header string Member string } // Returns if the event has any members which are not the event's blob payload, // nor a header. func eventHasNonBlobPayloadMembers(s Shape) bool { num := len(s.MemberRefs) for _, ref := range s.MemberRefs { if ref.IsEventHeader \|\| (ref.IsEventPayload && (ref.Shape.Type == "blob" \|\| ref.Shape.Type == "string")) { num-- } } return num > 0 } func setEventHeaderValueForType(s Shape, memVar string) string { switch s.Type { case "blob": return fmt.Sprintf("eventstream.BytesValue(%s)", memVar) case "string": return fmt.Sprintf("eventstream.StringValue(%s)", memVar) case "boolean": return fmt.Sprintf("eventstream.BoolValue(%s)", memVar) case "byte": return fmt.Sprintf("eventstream.Int8Value(int8(%s))", memVar) case "short": return fmt.Sprintf("eventstream.Int16Value(int16(%s))", memVar) case "integer": return fmt.Sprintf("eventstream.Int32Value(int32(%s))", memVar) case "long": return fmt.Sprintf("eventstream.Int64Value(%s)", memVar) case "float": return fmt.Sprintf("eventstream.Float32Value(float32(%s))", memVar) case "double": return fmt.Sprintf("eventstream.Float64Value(%s)", memVar) case "timestamp": return fmt.Sprintf("eventstream.TimestampValue(%s)", memVar) default: panic(fmt.Sprintf("value type %s not supported for event headers, %s", s.Type, s.ShapeName)) } } func shapeMessageType(s Shape) string { if s.Exception { return "eventstreamapi.ExceptionMessageType" } return "eventstreamapi.EventMessageType" } var eventStreamEventShapeTmplFuncs = template.FuncMap{ "EventStreamHeaderTypeMap": func(ref ShapeRef) EventStreamHeaderTypeMap { switch ref.Shape.Type { case "boolean": return EventStreamHeaderTypeMap{Header: "bool", Member: "bool"} case "byte": return EventStreamHeaderTypeMap{Header: "int8", Member: "int64"} case "short": return EventStreamHeaderTypeMap{Header: "int16", Member: "int64"} case "integer": return EventStreamHeaderTypeMap{Header: "int32", Member: "int64"} case "long": return EventStreamHeaderTypeMap{Header: "int64", Member: "int64"} case "timestamp": return EventStreamHeaderTypeMap{Header: "time.Time", Member: "time.Time"} case "blob": return EventStreamHeaderTypeMap{Header: "[]byte", Member: "[]byte"} case "string": return EventStreamHeaderTypeMap{Header: "string", Member: "string"} case "uuid": return EventStreamHeaderTypeMap{Header: "[]byte", Member: "[]byte"} default: panic("unsupported EventStream header type, " + ref.Shape.Type) } }, "EventHeaderValueForType": setEventHeaderValueForType, "ShapeMessageType": shapeMessageType, "HasNonBlobPayloadMembers": eventHasNonBlobPayloadMembers, } // Template for an EventStream Event shape. This is a normal API shape that is // decorated as an EventStream Event. // // Executed in the context of a Shape. var eventStreamEventShapeTmpl = template.Must(template.New("eventStreamEventShapeTmpl"). Funcs(eventStreamEventShapeTmplFuncs).Parse(` {{ range $_, $eventStream := $.EventFor }} // The {{ $.ShapeName }} is and event in the {{ $eventStream.Name }} group of events. func (s {{ $.ShapeName }}) event{{ $eventStream.Name }}() {} {{ end }} // UnmarshalEvent unmarshals the EventStream Message into the {{ $.ShapeName }} value. // This method is only used internally within the SDK's EventStream handling. func (s {{ $.ShapeName }}) UnmarshalEvent( payloadUnmarshaler protocol.PayloadUnmarshaler, msg eventstream.Message, ) error { {{- range $memName, $memRef := $.MemberRefs }} {{- if $memRef.IsEventHeader }} if hv := msg.Headers.Get("{{ $memName }}"); hv != nil { {{ $types := EventStreamHeaderTypeMap $memRef -}} v := hv.Get().({{ $types.Header }}) {{- if ne $types.Header $types.Member }} m := {{ $types.Member }}(v) s.{{ $memName }} = {{ if $memRef.UseIndirection }}&{{ end }}m {{- else }} s.{{ $memName }} = {{ if $memRef.UseIndirection }}&{{ end }}v {{- end }} } {{- else if (and ($memRef.IsEventPayload) (eq $memRef.Shape.Type "blob")) }} s.{{ $memName }} = make([]byte, len(msg.Payload)) copy(s.{{ $memName }}, msg.Payload) {{- else if (and ($memRef.IsEventPayload) (eq $memRef.Shape.Type "string")) }} s.{{ $memName }} = aws.String(string(msg.Payload)) {{- end }} {{- end }} {{- if HasNonBlobPayloadMembers $ }} if err := payloadUnmarshaler.UnmarshalPayload( bytes.NewReader(msg.Payload), s, ); err != nil { return err } {{- end }} return nil } // MarshalEvent marshals the type into an stream event value. This method // should only used internally within the SDK's EventStream handling. func (s {{ $.ShapeName}}) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue({{ ShapeMessageType $ }})) {{- range $memName, $memRef := $.MemberRefs }} {{- if $memRef.IsEventHeader }} {{ $memVar := printf "s.%s" $memName -}} {{ $typedMem := EventHeaderValueForType $memRef.Shape $memVar -}} msg.Headers.Set("{{ $memName }}", {{ $typedMem }}) {{- else if (and ($memRef.IsEventPayload) (eq $memRef.Shape.Type "blob")) }} msg.Headers.Set(":content-type", eventstream.StringValue("application/octet-stream")) msg.Payload = s.{{ $memName }} {{- else if (and ($memRef.IsEventPayload) (eq $memRef.Shape.Type "string")) }} msg.Payload = []byte(aws.StringValue(s.{{ $memName }})) {{- end }} {{- end }} {{- if HasNonBlobPayloadMembers $ }} var buf bytes.Buffer if err = pm.MarshalPayload(&buf, s); err != nil { return eventstream.Message{}, err } msg.Payload = buf.Bytes() {{- end }} return msg, err } `))	19.5 KB	2025-05-25 12:27
📄 eventstream_tmpl_reader.go //go:build codegen // +build codegen package api import "text/template" var eventStreamShapeReaderTmpl = template.Must(template.New("eventStreamShapeReaderTmpl"). Funcs(template.FuncMap{}). Parse(` {{- $es := $.EventStream }} // {{ $es.StreamReaderAPIName }} provides the interface for reading to the stream. The // default implementation for this interface will be {{ $.ShapeName }}. // // The reader's Close method must allow multiple concurrent calls. // // These events are: // {{ range $_, $event := $es.Events }} // * {{ $event.Shape.ShapeName }} {{- end }} // * {{ $es.StreamUnknownEventName }} type {{ $es.StreamReaderAPIName }} interface { // Returns a channel of events as they are read from the event stream. Events() <-chan {{ $es.EventGroupName }} // Close will stop the reader reading events from the stream. Close() error // Returns any error that has occurred while reading from the event stream. Err() error } type {{ $es.StreamReaderImplName }} struct { eventReader eventstreamapi.EventReader stream chan {{ $es.EventGroupName }} err eventstreamapi.OnceError done chan struct{} closeOnce sync.Once } func {{ $es.StreamReaderImplConstructorName }}(eventReader eventstreamapi.EventReader) {{ $es.StreamReaderImplName }} { r := &{{ $es.StreamReaderImplName }}{ eventReader: eventReader, stream: make(chan {{ $es.EventGroupName }}), done: make(chan struct{}), err: eventstreamapi.NewOnceError(), } go r.readEventStream() return r } // Close will close the underlying event stream reader. func (r {{ $es.StreamReaderImplName }}) Close() error { r.closeOnce.Do(r.safeClose) return r.Err() } func (r {{ $es.StreamReaderImplName }}) ErrorSet() <-chan struct{} { return r.err.ErrorSet() } func (r {{ $es.StreamReaderImplName }}) Closed() <-chan struct{} { return r.done } func (r {{ $es.StreamReaderImplName }}) safeClose() { close(r.done) } func (r {{ $es.StreamReaderImplName }}) Err() error { return r.err.Err() } func (r {{ $es.StreamReaderImplName }}) Events() <-chan {{ $es.EventGroupName }} { return r.stream } func (r {{ $es.StreamReaderImplName }}) readEventStream() { defer r.Close() defer close(r.stream) for { event, err := r.eventReader.ReadEvent() if err != nil { if err == io.EOF { return } select { case <-r.done: // If closed already ignore the error return default: } if _, ok := err.(eventstreamapi.UnknownMessageTypeError); ok { continue } r.err.SetError(err) return } select { case r.stream <- event.({{ $es.EventGroupName }}): case <-r.done: return } } } type {{ $es.StreamUnmarshalerForEventName }} struct { metadata protocol.ResponseMetadata } func (u {{ $es.StreamUnmarshalerForEventName }}) UnmarshalerForEventName(eventType string) (eventstreamapi.Unmarshaler, error) { switch eventType { {{- range $_, $event := $es.Events }} case {{ printf "%q" $event.Name }}: return &{{ $event.Shape.ShapeName }}{}, nil {{- end }} {{- range $_, $event := $es.Exceptions }} case {{ printf "%q" $event.Name }}: return newError{{ $event.Shape.ShapeName }}(u.metadata).(eventstreamapi.Unmarshaler), nil {{- end }} default: return &{{ $es.StreamUnknownEventName }}{Type: eventType}, nil } } // {{ $es.StreamUnknownEventName }} provides a failsafe event for the // {{ $es.Name }} group of events when an unknown event is received. type {{ $es.StreamUnknownEventName }} struct { Type string Message eventstream.Message } // The {{ $es.StreamUnknownEventName }} is and event in the {{ $es.Name }} // group of events. func (s {{ $es.StreamUnknownEventName }}) event{{ $es.Name }}() {} // MarshalEvent marshals the type into an stream event value. This method // should only used internally within the SDK's EventStream handling. func (e {{ $es.StreamUnknownEventName }}) MarshalEvent(pm protocol.PayloadMarshaler) ( msg eventstream.Message, err error, ) { return e.Message.Clone(), nil } // UnmarshalEvent unmarshals the EventStream Message into the {{ $.ShapeName }} value. // This method is only used internally within the SDK's EventStream handling. func (e *{{ $es.StreamUnknownEventName }}) UnmarshalEvent( payloadUnmarshaler protocol.PayloadUnmarshaler, msg eventstream.Message, ) error { e.Message = msg.Clone() return nil } `))	4.25 KB	2025-05-25 12:27
📄 eventstream_tmpl_readertests.go //go:build codegen // +build codegen package api import ( "text/template" ) var eventStreamReaderTestTmpl = template.Must( template.New("eventStreamReaderTestTmpl").Funcs(template.FuncMap{ "ValueForType": valueForType, "HasNonBlobPayloadMembers": eventHasNonBlobPayloadMembers, "EventHeaderValueForType": setEventHeaderValueForType, "Map": templateMap, "OptionalAddInt": func(do bool, a, b int) int { if !do { return a } return a + b }, "HasNonEventStreamMember": func(s Shape) bool { for _, ref := range s.MemberRefs { if !ref.Shape.IsEventStream { return true } } return false }, }).Parse(` {{ range $opName, $op := $.Operations }} {{ if $op.EventStreamAPI }} {{ if $op.EventStreamAPI.OutputStream }} {{ template "event stream outputStream tests" $op.EventStreamAPI }} {{ end }} {{ end }} {{ end }} type loopReader struct { source bytes.Reader } func (c loopReader) Read(p []byte) (int, error) { if c.source.Len() == 0 { c.source.Seek(0, 0) } return c.source.Read(p) } {{ define "event stream outputStream tests" }} func Test{{ $.Operation.ExportedName }}_Read(t testing.T) { expectEvents, eventMsgs := mock{{ $.Operation.ExportedName }}ReadEvents() sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t, eventstreamtest.ServeEventStream{ T: t, Events: eventMsgs, }, true, ) if err != nil { t.Fatalf("expect no error, %v", err) } defer cleanupFn() svc := New(sess) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { t.Fatalf("expect no error got, %v", err) } defer resp.GetStream().Close() {{- if eq $.Operation.API.Metadata.Protocol "json" }} {{- if HasNonEventStreamMember $.Operation.OutputRef.Shape }} expectResp := expectEvents[0].({{ $.Operation.OutputRef.Shape.ShapeName }}) {{- range $name, $ref := $.Operation.OutputRef.Shape.MemberRefs }} {{- if not $ref.Shape.IsEventStream }} if e, a := expectResp.{{ $name }}, resp.{{ $name }}; !reflect.DeepEqual(e,a) { t.Errorf("expect %v, got %v", e, a) } {{- end }} {{- end }} {{- end }} // Trim off response output type pseudo event so only event messages remain. expectEvents = expectEvents[1:] {{ end }} var i int for event := range resp.GetStream().Events() { if event == nil { t.Errorf("%d, expect event, got nil", i) } if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) { t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a) } i++ } if err := resp.GetStream().Err(); err != nil { t.Errorf("expect no error, %v", err) } } func Test{{ $.Operation.ExportedName }}_ReadClose(t testing.T) { _, eventMsgs := mock{{ $.Operation.ExportedName }}ReadEvents() sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t, eventstreamtest.ServeEventStream{ T: t, Events: eventMsgs, }, true, ) if err != nil { t.Fatalf("expect no error, %v", err) } defer cleanupFn() svc := New(sess) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { t.Fatalf("expect no error got, %v", err) } {{ if gt (len $.OutputStream.Events) 0 -}} // Assert calling Err before close does not close the stream. resp.GetStream().Err() select { case _, ok := <-resp.GetStream().Events(): if !ok { t.Fatalf("expect stream not to be closed, but was") } default: } {{- end }} resp.GetStream().Close() <-resp.GetStream().Events() if err := resp.GetStream().Err(); err != nil { t.Errorf("expect no error, %v", err) } } func Test{{ $.Operation.ExportedName }}_ReadUnknownEvent(t testing.T) { expectEvents, eventMsgs := mock{{ $.Operation.ExportedName }}ReadEvents() {{- if eq $.Operation.API.Metadata.Protocol "json" }} eventOffset := 1 {{- else }} var eventOffset int {{- end }} unknownEvent := eventstream.Message{ Headers: eventstream.Headers{ eventstreamtest.EventMessageTypeHeader, { Name: eventstreamapi.EventTypeHeader, Value: eventstream.StringValue("UnknownEventName"), }, }, Payload: []byte("some unknown event"), } eventMsgs = append(eventMsgs[:eventOffset], append([]eventstream.Message{unknownEvent}, eventMsgs[eventOffset:]...)...) expectEvents = append(expectEvents[:eventOffset], append([]{{ $.OutputStream.Name }}Event{ &{{ $.OutputStream.StreamUnknownEventName }}{ Type: "UnknownEventName", Message: unknownEvent, }, }, expectEvents[eventOffset:]...)...) sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t, eventstreamtest.ServeEventStream{ T: t, Events: eventMsgs, }, true, ) if err != nil { t.Fatalf("expect no error, %v", err) } defer cleanupFn() svc := New(sess) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { t.Fatalf("expect no error got, %v", err) } defer resp.GetStream().Close() {{- if eq $.Operation.API.Metadata.Protocol "json" }} // Trim off response output type pseudo event so only event messages remain. expectEvents = expectEvents[1:] {{ end }} var i int for event := range resp.GetStream().Events() { if event == nil { t.Errorf("%d, expect event, got nil", i) } if e, a := expectEvents[i], event; !reflect.DeepEqual(e, a) { t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a) } i++ } if err := resp.GetStream().Err(); err != nil { t.Errorf("expect no error, %v", err) } } func Benchmark{{ $.Operation.ExportedName }}_Read(b testing.B) { _, eventMsgs := mock{{ $.Operation.ExportedName }}ReadEvents() var buf bytes.Buffer encoder := eventstream.NewEncoder(&buf) for _, msg := range eventMsgs { if err := encoder.Encode(msg); err != nil { b.Fatalf("failed to encode message, %v", err) } } stream := &loopReader{source: bytes.NewReader(buf.Bytes())} sess := unit.Session svc := New(sess, &aws.Config{ Endpoint: aws.String("https://example.com"), DisableParamValidation: aws.Bool(true), }) svc.Handlers.Send.Swap(corehandlers.SendHandler.Name, request.NamedHandler{Name: "mockSend", Fn: func(r request.Request) { r.HTTPResponse = &http.Response{ Status: "200 OK", StatusCode: 200, Header: http.Header{}, Body: ioutil.NopCloser(stream), } }, }, ) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { b.Fatalf("failed to create request, %v", err) } defer resp.GetStream().Close() b.ResetTimer() for i := 0; i < b.N; i++ { if err = resp.GetStream().Err(); err != nil { b.Fatalf("expect no error, got %v", err) } event := <-resp.GetStream().Events() if event == nil { b.Fatalf("expect event, got nil, %v, %d", resp.GetStream().Err(), i) } } } func mock{{ $.Operation.ExportedName }}ReadEvents() ( []{{ $.OutputStream.Name }}Event, []eventstream.Message, ) { expectEvents := []{{ $.OutputStream.Name }}Event { {{- if eq $.Operation.API.Metadata.Protocol "json" }} {{- template "set event type" $.Operation.OutputRef.Shape }} {{- end }} {{- range $_, $event := $.OutputStream.Events }} {{- template "set event type" $event.Shape }} {{- end }} } var marshalers request.HandlerList marshalers.PushBackNamed({{ $.API.ProtocolPackage }}.BuildHandler) payloadMarshaler := protocol.HandlerPayloadMarshal{ Marshalers: marshalers, } _ = payloadMarshaler eventMsgs := []eventstream.Message{ {{- if eq $.Operation.API.Metadata.Protocol "json" }} {{- template "set event message" Map "idx" 0 "parentShape" $.Operation.OutputRef.Shape "eventName" "initial-response" }} {{- end }} {{- range $idx, $event := $.OutputStream.Events }} {{- $offsetIdx := OptionalAddInt (eq $.Operation.API.Metadata.Protocol "json") $idx 1 }} {{- template "set event message" Map "idx" $offsetIdx "parentShape" $event.Shape "eventName" $event.Name }} {{- end }} } return expectEvents, eventMsgs } {{- if $.OutputStream.Exceptions }} func Test{{ $.Operation.ExportedName }}_ReadException(t testing.T) { expectEvents := []{{ $.OutputStream.Name }}Event { {{- if eq $.Operation.API.Metadata.Protocol "json" }} {{- template "set event type" $.Operation.OutputRef.Shape }} {{- end }} {{- $exception := index $.OutputStream.Exceptions 0 }} {{- template "set event type" $exception.Shape }} } var marshalers request.HandlerList marshalers.PushBackNamed({{ $.API.ProtocolPackage }}.BuildHandler) payloadMarshaler := protocol.HandlerPayloadMarshal{ Marshalers: marshalers, } eventMsgs := []eventstream.Message{ {{- if eq $.Operation.API.Metadata.Protocol "json" }} {{- template "set event message" Map "idx" 0 "parentShape" $.Operation.OutputRef.Shape "eventName" "initial-response" }} {{- end }} {{- $offsetIdx := OptionalAddInt (eq $.Operation.API.Metadata.Protocol "json") 0 1 }} {{- $exception := index $.OutputStream.Exceptions 0 }} {{- template "set event message" Map "idx" $offsetIdx "parentShape" $exception.Shape "eventName" $exception.Name }} } sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t, eventstreamtest.ServeEventStream{ T: t, Events: eventMsgs, }, true, ) if err != nil { t.Fatalf("expect no error, %v", err) } defer cleanupFn() svc := New(sess) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { t.Fatalf("expect no error got, %v", err) } defer resp.GetStream().Close() <-resp.GetStream().Events() err = resp.GetStream().Err() if err == nil { t.Fatalf("expect err, got none") } expectErr := {{ ValueForType $exception.Shape nil }} aerr, ok := err.(awserr.Error) if !ok { t.Errorf("expect exception, got %T, %#v", err, err) } if e, a := expectErr.Code(), aerr.Code(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectErr.Message(), aerr.Message(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectErr, aerr; !reflect.DeepEqual(e, a) { t.Errorf("expect error %+#v, got %+#v", e, a) } } {{- range $_, $exception := $.OutputStream.Exceptions }} var _ awserr.Error = ({{ $exception.Shape.ShapeName }})(nil) {{- end }} {{ end }} {{ end }} {{/ Params: Shape /}} {{ define "set event type" }} &{{ $.ShapeName }}{ {{- if $.Exception }} RespMetadata: protocol.ResponseMetadata{ StatusCode: 200, }, {{- end }} {{- range $memName, $memRef := $.MemberRefs }} {{- if not $memRef.Shape.IsEventStream }} {{ $memName }}: {{ ValueForType $memRef.Shape nil }}, {{- end }} {{- end }} }, {{- end }} {{/* Params: idx:int, parentShape:Shape, eventName:string /}} {{ define "set event message" }} { Headers: eventstream.Headers{ {{- if $.parentShape.Exception }} eventstreamtest.EventExceptionTypeHeader, { Name: eventstreamapi.ExceptionTypeHeader, Value: eventstream.StringValue("{{ $.eventName }}"), }, {{- else }} eventstreamtest.EventMessageTypeHeader, { Name: eventstreamapi.EventTypeHeader, Value: eventstream.StringValue("{{ $.eventName }}"), }, {{- end }} {{- range $memName, $memRef := $.parentShape.MemberRefs }} {{- template "set event message header" Map "idx" $.idx "parentShape" $.parentShape "memName" $memName "memRef" $memRef }} {{- end }} }, {{- template "set event message payload" Map "idx" $.idx "parentShape" $.parentShape }} }, {{- end }} {{/* Params: idx:int, parentShape:Shape, memName:string, memRef:ShapeRef /}} {{ define "set event message header" }} {{- if $.memRef.IsEventHeader }} { Name: "{{ $.memName }}", {{- $shapeValueVar := printf "expectEvents[%d].(%s).%s" $.idx $.parentShape.GoType $.memName }} Value: {{ EventHeaderValueForType $.memRef.Shape $shapeValueVar }}, }, {{- end }} {{- end }} {{/ Params: idx:int, parentShape:Shape, memName:string, memRef:ShapeRef /}} {{ define "set event message payload" }} {{- $payloadMemName := $.parentShape.PayloadRefName }} {{- if HasNonBlobPayloadMembers $.parentShape }} Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, expectEvents[{{ $.idx }}]), {{- else if $payloadMemName }} {{- $shapeType := (index $.parentShape.MemberRefs $payloadMemName).Shape.Type }} {{- if eq $shapeType "blob" }} Payload: expectEvents[{{ $.idx }}].({{ $.parentShape.GoType }}).{{ $payloadMemName }}, {{- else if eq $shapeType "string" }} Payload: []byte(expectEvents[{{ $.idx }}].({{ $.parentShape.GoType }}).{{ $payloadMemName }}), {{- end }} {{- end }} {{- end }} `))	12.5 KB	2025-05-25 12:27
📄 eventstream_tmpl_tests.go //go:build codegen // +build codegen package api import ( "bytes" "fmt" "strings" ) // APIEventStreamTestGoCode generates Go code for EventStream operation tests. func (a API) APIEventStreamTestGoCode() string { var buf bytes.Buffer a.resetImports() a.AddImport("bytes") a.AddImport("io/ioutil") a.AddImport("net/http") a.AddImport("reflect") a.AddImport("testing") a.AddImport("time") a.AddImport("context") a.AddImport("strings") a.AddImport("sync") a.AddSDKImport("aws") a.AddSDKImport("aws/corehandlers") a.AddSDKImport("aws/request") a.AddSDKImport("aws/awserr") a.AddSDKImport("awstesting/unit") a.AddSDKImport("private/protocol") a.AddSDKImport("private/protocol/", a.ProtocolPackage()) a.AddSDKImport("private/protocol/eventstream") a.AddSDKImport("private/protocol/eventstream/eventstreamapi") a.AddSDKImport("private/protocol/eventstream/eventstreamtest") unused := ` var _ time.Time var _ awserr.Error var _ context.Context var _ sync.WaitGroup var _ strings.Reader ` if err := eventStreamReaderTestTmpl.Execute(&buf, a); err != nil { panic(err) } if err := eventStreamWriterTestTmpl.Execute(&buf, a); err != nil { panic(err) } return a.importsGoCode() + unused + strings.TrimSpace(buf.String()) } func templateMap(args ...interface{}) map[string]interface{} { if len(args)%2 != 0 { panic(fmt.Sprintf("invalid map call, non-even args %v", args)) } m := map[string]interface{}{} for i := 0; i < len(args); i += 2 { k, ok := args[i].(string) if !ok { panic(fmt.Sprintf("invalid map call, arg is not string, %T, %v", args[i], args[i])) } m[k] = args[i+1] } return m } func valueForType(s Shape, visited []string) string { if isShapeVisited(visited, s.ShapeName) { return "nil" } visited = append(visited, s.ShapeName) switch s.Type { case "blob": return `[]byte("blob value goes here")` case "string": return `aws.String("string value goes here")` case "boolean": return `aws.Bool(true)` case "byte": return `aws.Int64(1)` case "short": return `aws.Int64(12)` case "integer": return `aws.Int64(123)` case "long": return `aws.Int64(1234)` case "float": return `aws.Float64(123.4)` case "double": return `aws.Float64(123.45)` case "timestamp": return `aws.Time(time.Unix(1396594860, 0).UTC())` case "structure": w := bytes.NewBuffer(nil) fmt.Fprintf(w, "&%s{\n", s.ShapeName) if s.Exception { fmt.Fprintf(w, `RespMetadata: protocol.ResponseMetadata{ StatusCode: 200, }, `) } for _, refName := range s.MemberNames() { fmt.Fprintf(w, "%s: %s,\n", refName, valueForType(s.MemberRefs[refName].Shape, visited)) } fmt.Fprintf(w, "}") return w.String() case "list": w := bytes.NewBuffer(nil) fmt.Fprintf(w, "%s{\n", s.GoType()) if !isShapeVisited(visited, s.MemberRef.Shape.ShapeName) { for i := 0; i < 3; i++ { fmt.Fprintf(w, "%s,\n", valueForType(s.MemberRef.Shape, visited)) } } fmt.Fprintf(w, "}") return w.String() case "map": w := bytes.NewBuffer(nil) fmt.Fprintf(w, "%s{\n", s.GoType()) if !isShapeVisited(visited, s.ValueRef.Shape.ShapeName) { for _, k := range []string{"a", "b", "c"} { fmt.Fprintf(w, "%q: %s,\n", k, valueForType(s.ValueRef.Shape, visited)) } } fmt.Fprintf(w, "}") return w.String() default: panic(fmt.Sprintf("valueForType does not support %s, %s", s.ShapeName, s.Type)) } } func isShapeVisited(visited []string, name string) bool { for _, v := range visited { if v == name { return true } } return false }	3.45 KB	2025-05-25 12:27
📄 eventstream_tmpl_writer.go //go:build codegen // +build codegen package api import "text/template" var eventStreamShapeWriterTmpl = template.Must(template.New("eventStreamShapeWriterTmpl"). Funcs(template.FuncMap{}). Parse(` {{- $es := $.EventStream }} // {{ $es.StreamWriterAPIName }} provides the interface for writing events to the stream. // The default implementation for this interface will be {{ $.ShapeName }}. // // The writer's Close method must allow multiple concurrent calls. // // These events are: // {{ range $_, $event := $es.Events }} // * {{ $event.Shape.ShapeName }} {{- end }} type {{ $es.StreamWriterAPIName }} interface { // Sends writes events to the stream blocking until the event has been // written. An error is returned if the write fails. Send(aws.Context, {{ $es.EventGroupName }}) error // Close will stop the writer writing to the event stream. Close() error // Returns any error that has occurred while writing to the event stream. Err() error } type {{ $es.StreamWriterImplName }} struct { eventstreamapi.StreamWriter } func (w {{ $es.StreamWriterImplName }}) Send(ctx aws.Context, event {{ $es.EventGroupName }}) error { return w.StreamWriter.Send(ctx, event) } func {{ $es.StreamEventTypeGetterName }}(event eventstreamapi.Marshaler) (string, error) { switch event.(type) { {{- range $_, $event := $es.Events }} case {{ $event.Shape.ShapeName }}: return {{ printf "%q" $event.Name }}, nil {{- end }} {{- range $_, $event := $es.Exceptions }} case {{ $event.Shape.ShapeName }}: return {{ printf "%q" $event.Name }}, nil {{- end }} default: return "", awserr.New( request.ErrCodeSerialization, fmt.Sprintf("unknown event type, %T, for {{ $es.Name }}", event), nil, ) } } `))	1.71 KB	2025-05-25 12:27
📄 eventstream_tmpl_writertests.go //go:build codegen // +build codegen package api import ( "text/template" ) var eventStreamWriterTestTmpl = template.Must( template.New("eventStreamWriterTestTmpl").Funcs(template.FuncMap{ "ValueForType": valueForType, "HasNonBlobPayloadMembers": eventHasNonBlobPayloadMembers, "EventHeaderValueForType": setEventHeaderValueForType, "Map": templateMap, "OptionalAddInt": func(do bool, a, b int) int { if !do { return a } return a + b }, "HasNonEventStreamMember": func(s Shape) bool { for _, ref := range s.MemberRefs { if !ref.Shape.IsEventStream { return true } } return false }, }).Parse(` {{ range $opName, $op := $.Operations }} {{ if $op.EventStreamAPI }} {{ if $op.EventStreamAPI.InputStream }} {{ template "event stream inputStream tests" $op.EventStreamAPI }} {{ end }} {{ end }} {{ end }} {{ define "event stream inputStream tests" }} func Test{{ $.Operation.ExportedName }}_Write(t testing.T) { clientEvents, expectedClientEvents := mock{{ $.Operation.ExportedName }}WriteEvents() sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t, &eventstreamtest.ServeEventStream{ T: t, ClientEvents: expectedClientEvents, BiDirectional: true, }, true) defer cleanupFn() svc := New(sess) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { t.Fatalf("expect no error, got %v", err) } stream := resp.GetStream() for _, event := range clientEvents { err = stream.Send(context.Background(), event) if err != nil { t.Fatalf("expect no error, got %v", err) } } if err := stream.Close(); err != nil { t.Errorf("expect no error, got %v", err) } } func Test{{ $.Operation.ExportedName }}_WriteClose(t testing.T) { sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t, eventstreamtest.ServeEventStream{T: t, BiDirectional: true}, true, ) if err != nil { t.Fatalf("expect no error, %v", err) } defer cleanupFn() svc := New(sess) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { t.Fatalf("expect no error got, %v", err) } // Assert calling Err before close does not close the stream. resp.GetStream().Err() {{ $eventShape := index $.InputStream.Events 0 }} err = resp.GetStream().Send(context.Background(), &{{ $eventShape.Shape.ShapeName }}{}) if err != nil { t.Fatalf("expect no error, got %v", err) } resp.GetStream().Close() if err := resp.GetStream().Err(); err != nil { t.Errorf("expect no error, %v", err) } } func Test{{ $.Operation.ExportedName }}_WriteError(t testing.T) { sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t, eventstreamtest.ServeEventStream{ T: t, BiDirectional: true, ForceCloseAfter: time.Millisecond * 500, }, true, ) if err != nil { t.Fatalf("expect no error, %v", err) } defer cleanupFn() svc := New(sess) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { t.Fatalf("expect no error got, %v", err) } defer resp.GetStream().Close() {{ $eventShape := index $.InputStream.Events 0 }} for { err = resp.GetStream().Send(context.Background(), &{{ $eventShape.Shape.ShapeName }}{}) if err != nil { if strings.Contains("unable to send event", err.Error()) { t.Errorf("expected stream closed error, got %v", err) } break } } } func Test{{ $.Operation.ExportedName }}_ReadWrite(t testing.T) { expectedServiceEvents, serviceEvents := mock{{ $.Operation.ExportedName }}ReadEvents() clientEvents, expectedClientEvents := mock{{ $.Operation.ExportedName }}WriteEvents() sess, cleanupFn, err := eventstreamtest.SetupEventStreamSession(t, &eventstreamtest.ServeEventStream{ T: t, ClientEvents: expectedClientEvents, Events: serviceEvents, BiDirectional: true, }, true) defer cleanupFn() svc := New(sess) resp, err := svc.{{ $.Operation.ExportedName }}(nil) if err != nil { t.Fatalf("expect no error, got %v", err) } stream := resp.GetStream() defer stream.Close() var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() var i int for event := range resp.GetStream().Events() { if event == nil { t.Errorf("%d, expect event, got nil", i) } if e, a := expectedServiceEvents[i], event; !reflect.DeepEqual(e, a) { t.Errorf("%d, expect %T %v, got %T %v", i, e, e, a, a) } i++ } }() for _, event := range clientEvents { err = stream.Send(context.Background(), event) if err != nil { t.Errorf("expect no error, got %v", err) } } resp.GetStream().Close() wg.Wait() if err := resp.GetStream().Err(); err != nil { t.Errorf("expect no error, %v", err) } } func mock{{ $.Operation.ExportedName }}WriteEvents() ( []{{ $.InputStream.Name }}Event, []eventstream.Message, ) { inputEvents := []{{ $.InputStream.Name }}Event { {{- if eq $.Operation.API.Metadata.Protocol "json" }} {{- template "set event type" $.Operation.InputRef.Shape }} {{- end }} {{- range $_, $event := $.InputStream.Events }} {{- template "set event type" $event.Shape }} {{- end }} } var marshalers request.HandlerList marshalers.PushBackNamed({{ $.API.ProtocolPackage }}.BuildHandler) payloadMarshaler := protocol.HandlerPayloadMarshal{ Marshalers: marshalers, } _ = payloadMarshaler eventMsgs := []eventstream.Message{ {{- range $idx, $event := $.InputStream.Events }} {{- template "set event message" Map "idx" $idx "parentShape" $event.Shape "eventName" $event.Name }} {{- end }} } return inputEvents, eventMsgs } {{ end }} {{/ Params: Shape /}} {{ define "set event type" }} &{{ $.ShapeName }}{ {{- range $memName, $memRef := $.MemberRefs }} {{- if not $memRef.Shape.IsEventStream }} {{ $memName }}: {{ ValueForType $memRef.Shape nil }}, {{- end }} {{- end }} }, {{- end }} {{/* Params: idx:int, parentShape:Shape, eventName:string /}} {{ define "set event message" }} { Headers: eventstream.Headers{ eventstreamtest.EventMessageTypeHeader, {{- range $memName, $memRef := $.parentShape.MemberRefs }} {{- template "set event message header" Map "idx" $.idx "parentShape" $.parentShape "memName" $memName "memRef" $memRef }} {{- end }} { Name: eventstreamapi.EventTypeHeader, Value: eventstream.StringValue("{{ $.eventName }}"), }, }, {{- template "set event message payload" Map "idx" $.idx "parentShape" $.parentShape }} }, {{- end }} {{/* Params: idx:int, parentShape:Shape, memName:string, memRef:ShapeRef /}} {{ define "set event message header" }} {{- if (and ($.memRef.IsEventPayload) (eq $.memRef.Shape.Type "blob")) }} { Name: ":content-type", Value: eventstream.StringValue("application/octet-stream"), }, {{- else if $.memRef.IsEventHeader }} { Name: "{{ $.memName }}", {{- $shapeValueVar := printf "inputEvents[%d].(%s).%s" $.idx $.parentShape.GoType $.memName }} Value: {{ EventHeaderValueForType $.memRef.Shape $shapeValueVar }}, }, {{- end }} {{- end }} {{/ Params: idx:int, parentShape:Shape, memName:string, memRef:ShapeRef /}} {{ define "set event message payload" }} {{- $payloadMemName := $.parentShape.PayloadRefName }} {{- if HasNonBlobPayloadMembers $.parentShape }} Payload: eventstreamtest.MarshalEventPayload(payloadMarshaler, inputEvents[{{ $.idx }}]), {{- else if $payloadMemName }} {{- $shapeType := (index $.parentShape.MemberRefs $payloadMemName).Shape.Type }} {{- if eq $shapeType "blob" }} Payload: inputEvents[{{ $.idx }}].({{ $.parentShape.GoType }}).{{ $payloadMemName }}, {{- else if eq $shapeType "string" }} Payload: []byte(inputEvents[{{ $.idx }}].({{ $.parentShape.GoType }}).{{ $payloadMemName }}), {{- end }} {{- end }} {{- end }} `))	7.74 KB	2025-05-25 12:27
📄 example.go //go:build codegen // +build codegen package api import ( "bytes" "encoding/json" "fmt" "os" "sort" "strings" "text/template" "github.com/aws/aws-sdk-go/private/util" ) type Examples map[string][]Example // ExamplesDefinition is the structural representation of the examples-1.json file type ExamplesDefinition struct { API `json:"-"` Examples Examples `json:"examples"` } // Example is a single entry within the examples-1.json file. type Example struct { API API `json:"-"` Operation Operation `json:"-"` OperationName string `json:"-"` Index string `json:"-"` Builder examplesBuilder `json:"-"` VisitedErrors map[string]struct{} `json:"-"` Title string `json:"title"` Description string `json:"description"` ID string `json:"id"` Comments Comments `json:"comments"` Input map[string]interface{} `json:"input"` Output map[string]interface{} `json:"output"` } type Comments struct { Input map[string]interface{} `json:"input"` Output map[string]interface{} `json:"output"` } var exampleFuncMap = template.FuncMap{ "commentify": commentify, "wrap": wrap, "generateExampleInput": generateExampleInput, "generateTypes": generateTypes, } var exampleCustomizations = map[string]template.FuncMap{} var exampleTmpls = template.Must(template.New("example").Funcs(exampleFuncMap).Parse(` {{ generateTypes . }} {{ commentify (wrap .Title 80) }} // {{ commentify (wrap .Description 80) }} func Example{{ .API.StructName }}_{{ .MethodName }}() { svc := {{ .API.PackageName }}.New(session.New()) input := {{ generateExampleInput . }} result, err := svc.{{ .OperationName }}(input) if err != nil { if aerr, ok := err.(awserr.Error); ok { switch aerr.Code() { {{ range $_, $ref := .Operation.ErrorRefs -}} {{ if not ($.HasVisitedError $ref) -}} case {{ .API.PackageName }}.{{ $ref.Shape.ErrorCodeName }}: fmt.Println({{ .API.PackageName }}.{{ $ref.Shape.ErrorCodeName }}, aerr.Error()) {{ end -}} {{ end -}} default: fmt.Println(aerr.Error()) } } else { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) } return } fmt.Println(result) } `)) // Names will return the name of the example. This will also be the name of the operation // that is to be tested. func (exs Examples) Names() []string { names := make([]string, 0, len(exs)) for k := range exs { names = append(names, k) } sort.Strings(names) return names } func (exs Examples) GoCode() string { buf := bytes.NewBuffer(nil) for _, opName := range exs.Names() { examples := exs[opName] for _, ex := range examples { buf.WriteString(util.GoFmt(ex.GoCode())) buf.WriteString("\n") } } return buf.String() } // ExampleCode will generate the example code for the given Example shape. // TODO: Can delete func (ex Example) GoCode() string { var buf bytes.Buffer m := exampleFuncMap if fMap, ok := exampleCustomizations[ex.API.PackageName()]; ok { m = fMap } tmpl := exampleTmpls.Funcs(m) if err := tmpl.ExecuteTemplate(&buf, "example", &ex); err != nil { panic(err) } return strings.TrimSpace(buf.String()) } func generateExampleInput(ex Example) string { if ex.Operation.HasInput() { return fmt.Sprintf("&%s{\n%s\n}", ex.Builder.GoType(&ex.Operation.InputRef, true), ex.Builder.BuildShape(&ex.Operation.InputRef, ex.Input, false), ) } return "" } // generateTypes will generate no types for default examples, but customizations may // require their own defined types. func generateTypes(ex Example) string { return "" } // correctType will cast the value to the correct type when printing the string. // This is due to the json decoder choosing numbers to be floats, but the shape may // actually be an int. To counter this, we pass the shape's type and properly do the // casting here. func correctType(memName string, t string, value interface{}) string { if value == nil { return "" } v := "" switch value.(type) { case string: v = value.(string) case int: v = fmt.Sprintf("%d", value.(int)) case float64: if t == "integer" \|\| t == "long" \|\| t == "int64" { v = fmt.Sprintf("%d", int(value.(float64))) } else { v = fmt.Sprintf("%f", value.(float64)) } case bool: v = fmt.Sprintf("%t", value.(bool)) } return convertToCorrectType(memName, t, v) } func convertToCorrectType(memName, t, v string) string { return fmt.Sprintf("%s: %s,\n", memName, getValue(t, v)) } func getValue(t, v string) string { if t[0] == '' { t = t[1:] } switch t { case "string": return fmt.Sprintf("aws.String(%q)", v) case "integer", "long", "int64": return fmt.Sprintf("aws.Int64(%s)", v) case "float", "float64", "double": return fmt.Sprintf("aws.Float64(%s)", v) case "boolean": return fmt.Sprintf("aws.Bool(%s)", v) default: panic("Unsupported type: " + t) } } // AttachExamples will create a new ExamplesDefinition from the examples file // and reference the API object. func (a API) AttachExamples(filename string) error { p := ExamplesDefinition{API: a} f, err := os.Open(filename) defer f.Close() if err != nil { return err } err = json.NewDecoder(f).Decode(&p) if err != nil { return fmt.Errorf("failed to decode %s, err: %v", filename, err) } return p.setup() } var examplesBuilderCustomizations = map[string]examplesBuilder{ "wafregional": NewWAFregionalExamplesBuilder(), } func (p ExamplesDefinition) setup() error { var builder examplesBuilder ok := false if builder, ok = examplesBuilderCustomizations[p.API.PackageName()]; !ok { builder = NewExamplesBuilder() } filteredExamples := make(Examples) for _, n := range p.Examples.Names() { examples := p.Examples[n] n = p.ExportableName(n) if _, ok := p.API.Operations[n]; !ok { continue } filteredExamples[n] = make([]Example, 0, len(examples)) for i, e := range examples { e.OperationName = n e.API = p.API e.Index = fmt.Sprintf("shared%02d", i) e.Builder = builder e.VisitedErrors = map[string]struct{}{} op := p.API.Operations[e.OperationName] e.Operation = op filteredExamples[n] = append(filteredExamples[n], e) } } p.Examples = filteredExamples p.API.Examples = p.Examples return nil } var exampleHeader = template.Must(template.New("exampleHeader").Parse(` import ( {{ .Builder.Imports .API }} ) var _ time.Duration var _ strings.Reader var _ aws.Config func parseTime(layout, value string) time.Time { t, err := time.Parse(layout, value) if err != nil { panic(err) } return &t } `)) type exHeader struct { Builder examplesBuilder API API } // ExamplesGoCode will return a code representation of the entry within the // examples.json file. func (a API) ExamplesGoCode() string { var buf bytes.Buffer var builder examplesBuilder ok := false if builder, ok = examplesBuilderCustomizations[a.PackageName()]; !ok { builder = NewExamplesBuilder() } if err := exampleHeader.ExecuteTemplate(&buf, "exampleHeader", &exHeader{builder, a}); err != nil { panic(err) } code := a.Examples.GoCode() if len(code) == 0 { return "" } buf.WriteString(code) return buf.String() } // TODO: In the operation docuentation where we list errors, this needs to be done // there as well. func (ex Example) HasVisitedError(errRef ShapeRef) bool { errName := errRef.Shape.ErrorCodeName() _, ok := ex.VisitedErrors[errName] ex.VisitedErrors[errName] = struct{}{} return ok } func (ex Example) MethodName() string { return fmt.Sprintf("%s_%s", ex.OperationName, ex.Index) }	7.6 KB	2025-05-25 12:27
📄 example_test.go //go:build go1.10 && codegen // +build go1.10,codegen package api import ( "encoding/json" "testing" "github.com/aws/aws-sdk-go/private/util" ) func buildAPI() API { a := &API{} stringShape := &Shape{ API: a, ShapeName: "string", Type: "string", } stringShapeRef := &ShapeRef{ API: a, ShapeName: "string", Shape: stringShape, } intShape := &Shape{ API: a, ShapeName: "int", Type: "int", } intShapeRef := &ShapeRef{ API: a, ShapeName: "int", Shape: intShape, } nestedComplexShape := &Shape{ API: a, ShapeName: "NestedComplexShape", MemberRefs: map[string]ShapeRef{ "NestedField": stringShapeRef, }, Type: "structure", } nestedComplexShapeRef := &ShapeRef{ API: a, ShapeName: "NestedComplexShape", Shape: nestedComplexShape, } nestedListShape := &Shape{ API: a, ShapeName: "NestedListShape", MemberRef: nestedComplexShapeRef, Type: "list", } nestedListShapeRef := &ShapeRef{ API: a, ShapeName: "NestedListShape", Shape: nestedListShape, } complexShape := &Shape{ API: a, ShapeName: "ComplexShape", MemberRefs: map[string]ShapeRef{ "Field": stringShapeRef, "List": nestedListShapeRef, }, Type: "structure", } complexShapeRef := &ShapeRef{ API: a, ShapeName: "ComplexShape", Shape: complexShape, } listShape := &Shape{ API: a, ShapeName: "ListShape", MemberRef: complexShapeRef, Type: "list", } listShapeRef := &ShapeRef{ API: a, ShapeName: "ListShape", Shape: listShape, } listsShape := &Shape{ API: a, ShapeName: "ListsShape", MemberRef: listShapeRef, Type: "list", } listsShapeRef := &ShapeRef{ API: a, ShapeName: "ListsShape", Shape: listsShape, } input := &Shape{ API: a, ShapeName: "FooInput", MemberRefs: map[string]ShapeRef{ "BarShape": stringShapeRef, "ComplexField": complexShapeRef, "ListField": listShapeRef, "ListsField": listsShapeRef, }, Type: "structure", } output := &Shape{ API: a, ShapeName: "FooOutput", MemberRefs: map[string]ShapeRef{ "BazShape": intShapeRef, "ComplexField": complexShapeRef, "ListField": listShapeRef, "ListsField": listsShapeRef, }, Type: "structure", } inputRef := ShapeRef{ API: a, ShapeName: "FooInput", Shape: input, } outputRef := ShapeRef{ API: a, ShapeName: "FooOutput", Shape: output, } operations := map[string]Operation{ "Foo": { API: a, Name: "Foo", ExportedName: "Foo", InputRef: inputRef, OutputRef: outputRef, }, } a.Operations = operations a.Shapes = map[string]Shape{ "FooInput": input, "FooOutput": output, "string": stringShape, "int": intShape, "NestedComplexShape": nestedComplexShape, "NestedListShape": nestedListShape, "ComplexShape": complexShape, "ListShape": listShape, "ListsShape": listsShape, } a.Metadata = Metadata{ ServiceAbbreviation: "FooService", } a.BaseImportPath = "github.com/aws/aws-sdk-go/service/" a.Setup() return a } func TestExampleGeneration(t testing.T) { example := `{ "version": "1.0", "examples": { "Foo": [ { "input": { "BarShape": "Hello world", "ComplexField": { "Field": "bar", "List": [ { "NestedField": "qux" } ] }, "ListField": [ { "Field": "baz" } ], "ListsField": [ [ { "Field": "baz" } ] ], "FieldDoesNotExistInModel": true }, "output": { "BazShape": 1 }, "comments": { "input": { }, "output": { } }, "description": "Foo bar baz qux", "title": "I pity the foo" } ], "NotInTheModel": [ { "input": {}, "output": {}, "comments": { "input": { }, "output": { } }, "description": "Look the other way", "title": "I am not modeled" } ] } } ` a := buildAPI() def := &ExamplesDefinition{} err := json.Unmarshal([]byte(example), def) if err != nil { t.Error(err) } def.API = a def.setup() expected := `import ( "bytes" "fmt" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/fooservice" ) var _ time.Duration var _ bytes.Buffer func ExampleFooService_Foo() { sess := session.Must(session.NewSession()) svc := fooservice.New(sess) params := &fooservice.FooInput{ BarShape: aws.String("string"), ComplexField: &fooservice.ComplexShape{ Field: aws.String("string"), List: []fooservice.NestedComplexShape{ &fooservice.NestedComplexShape{ // Required NestedField: aws.String("string"), }, // More values... }, }, ListField: []fooservice.ComplexShape{ &fooservice.ComplexShape{ // Required Field: aws.String("string"), List: []fooservice.NestedComplexShape{ &fooservice.NestedComplexShape{ // Required NestedField: aws.String("string"), }, // More values... }, }, // More values... }, ListsField: [][]fooservice.ComplexShape{ []fooservice.ComplexShape{ // Required &fooservice.ComplexShape{ // Required Field: aws.String("string"), List: []fooservice.NestedComplexShape{ &fooservice.NestedComplexShape{ // Required NestedField: aws.String("string"), }, // More values... }, }, // More values... }, // More values... }, } resp, err := svc.Foo(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }` if e, a := util.GoFmt(expected), util.GoFmt(a.ExampleGoCode()); e != a { t.Errorf("Expect:\n%s\nActual:\n%s\n", e, a) } } func TestBuildShape(t testing.T) { a := buildAPI() cases := []struct { defs map[string]interface{} expected string }{ { defs: map[string]interface{}{ "barShape": "Hello World", }, expected: "BarShape: aws.String(\"Hello World\"),\n", }, { defs: map[string]interface{}{ "BarShape": "Hello World", }, expected: "BarShape: aws.String(\"Hello World\"),\n", }, } for _, c := range cases { ref := a.Operations["Foo"].InputRef shapeStr := defaultExamplesBuilder{}.BuildShape(&ref, c.defs, false) if c.expected != shapeStr { t.Errorf("Expected:\n%s\nReceived:\n%s", c.expected, shapeStr) } } }	6.78 KB	2025-05-25 12:27
📄 examples_builder.go //go:build codegen // +build codegen package api import ( "fmt" "github.com/aws/aws-sdk-go/private/protocol" ) type examplesBuilder interface { BuildShape(ShapeRef, map[string]interface{}, bool) string BuildList(string, string, ShapeRef, []interface{}) string BuildComplex(string, string, ShapeRef, Shape, map[string]interface{}) string GoType(ShapeRef, bool) string Imports(API) string } type defaultExamplesBuilder struct { ShapeValueBuilder } // NewExamplesBuilder returns an initialized example builder for generating // example input API shapes from a model. func NewExamplesBuilder() defaultExamplesBuilder { b := defaultExamplesBuilder{ ShapeValueBuilder: NewShapeValueBuilder(), } b.ParseTimeString = parseExampleTimeString return b } func (builder defaultExamplesBuilder) Imports(a API) string { return `"fmt" "strings" "time" "` + SDKImportRoot + `/aws" "` + SDKImportRoot + `/aws/awserr" "` + SDKImportRoot + `/aws/session" "` + a.ImportPath() + `" ` } // Returns a string which assigns the value of a time member by calling // parseTime function defined in the file func parseExampleTimeString(ref ShapeRef, memName, v string) string { if ref.Location == "header" { return fmt.Sprintf("%s: parseTime(%q, %q),\n", memName, protocol.RFC822TimeFormat, v) } switch ref.API.Metadata.Protocol { case "json", "rest-json", "rest-xml", "ec2", "query": return fmt.Sprintf("%s: parseTime(%q, %q),\n", memName, protocol.ISO8601TimeFormat, v) default: panic("Unsupported time type: " + ref.API.Metadata.Protocol) } }	1.53 KB	2025-05-25 12:27
📄 examples_builder_customizations.go //go:build codegen // +build codegen package api type wafregionalExamplesBuilder struct { defaultExamplesBuilder } func NewWAFregionalExamplesBuilder() wafregionalExamplesBuilder { return wafregionalExamplesBuilder{defaultExamplesBuilder: NewExamplesBuilder()} } func (builder wafregionalExamplesBuilder) Imports(a *API) string { return `"fmt" "strings" "time" "` + SDKImportRoot + `/aws" "` + SDKImportRoot + `/aws/awserr" "` + SDKImportRoot + `/aws/session" "` + SDKImportRoot + `/service/waf" "` + SDKImportRoot + `/service/` + a.PackageName() + `" ` }	571 B	2025-05-25 12:27
📄 exportable_name.go //go:build codegen // +build codegen package api import "strings" // ExportableName a name which is exportable as a value or name in Go code func (a *API) ExportableName(name string) string { if name == "" { return name } return strings.ToUpper(name[0:1]) + name[1:] }	278 B	2025-05-25 12:27
📄 legacy_io_suffix.go //go:build codegen // +build codegen package api // IoSuffix represents map of service to shape names that // are suffixed with `Input`, `Output` string and are not // Input or Output shapes used by any operation within // the service enclosure. type IoSuffix map[string]map[string]struct{} // LegacyIoSuffix returns if the shape names are legacy // names that contain "Input" and "Output" name as suffix. func (i IoSuffix) LegacyIOSuffix(a *API, shapeName string) bool { names, ok := i[a.name] if !ok { return false } _, ok = names[shapeName] return ok } // legacyIOSuffixed is the list of known shapes that have "Input" and "Output" // as suffix in shape name, but are not the actual input, output shape // for a corresponding service operation. var legacyIOSuffixed = IoSuffix{ "TranscribeService": { "RedactionOutput": struct{}{}, }, "Textract": {"HumanLoopActivationOutput": struct{}{}}, "Synthetics": { "CanaryRunConfigInput": struct{}{}, "CanaryScheduleOutput": struct{}{}, "VpcConfigInput": struct{}{}, "VpcConfigOutput": struct{}{}, "CanaryCodeOutput": struct{}{}, "CanaryCodeInput": struct{}{}, "CanaryRunConfigOutput": struct{}{}, "CanaryScheduleInput": struct{}{}, }, "SWF": {"FunctionInput": struct{}{}}, "SFN": { "InvalidOutput": struct{}{}, "InvalidExecutionInput": struct{}{}, "SensitiveDataJobInput": struct{}{}, }, "SSM": { "CommandPluginOutput": struct{}{}, "MaintenanceWindowStepFunctionsInput": struct{}{}, "InvocationTraceOutput": struct{}{}, }, "SSMIncidents": {"RegionMapInput": struct{}{}}, "SMS": { "AppValidationOutput": struct{}{}, "ServerValidationOutput": struct{}{}, "ValidationOutput": struct{}{}, "SSMOutput": struct{}{}, }, "ServiceDiscovery": {"InvalidInput": struct{}{}}, "ServiceCatalog": { "RecordOutput": struct{}{}, "ProvisioningArtifactOutput": struct{}{}, }, "Schemas": { "GetDiscoveredSchemaVersionItemInput": struct{}{}, "__listOfGetDiscoveredSchemaVersionItemInput": struct{}{}, }, "SageMaker": { "ProcessingOutput": struct{}{}, "TaskInput": struct{}{}, "TransformOutput": struct{}{}, "ModelBiasJobInput": struct{}{}, "TransformInput": struct{}{}, "LabelingJobOutput": struct{}{}, "DataQualityJobInput": struct{}{}, "MonitoringOutput": struct{}{}, "MonitoringS3Output": struct{}{}, "MonitoringInput": struct{}{}, "ProcessingS3Output": struct{}{}, "ModelQualityJobInput": struct{}{}, "ProcessingInput": struct{}{}, "ProcessingFeatureStoreOutput": struct{}{}, "ModelExplainabilityJobInput": struct{}{}, "ProcessingS3Input": struct{}{}, "MonitoringGroundTruthS3Input": struct{}{}, "EdgePresetDeploymentOutput": struct{}{}, "EndpointInput": struct{}{}, }, "AugmentedAIRuntime": {"HumanLoopOutput": struct{}{}, "HumanLoopInput": struct{}{}}, "S3": { "ParquetInput": struct{}{}, "CSVOutput": struct{}{}, "JSONOutput": struct{}{}, "JSONInput": struct{}{}, "CSVInput": struct{}{}, }, "Route53Domains": {"InvalidInput": struct{}{}}, "Route53": {"InvalidInput": struct{}{}}, "RoboMaker": {"S3KeyOutput": struct{}{}}, "Rekognition": { "StreamProcessorInput": struct{}{}, "HumanLoopActivationOutput": struct{}{}, "StreamProcessorOutput": struct{}{}, }, "Proton": {"TemplateVersionSourceInput": struct{}{}, "CompatibleEnvironmentTemplateInput": struct{}{}}, "Personalize": { "BatchInferenceJobInput": struct{}{}, "BatchInferenceJobOutput": struct{}{}, "DatasetExportJobOutput": struct{}{}, }, "MWAA": { "ModuleLoggingConfigurationInput": struct{}{}, "LoggingConfigurationInput": struct{}{}, "UpdateNetworkConfigurationInput": struct{}{}, }, "MQ": {"LdapServerMetadataOutput": struct{}{}, "LdapServerMetadataInput": struct{}{}}, "MediaLive": { "InputDeviceConfiguredInput": struct{}{}, "__listOfOutput": struct{}{}, "Input": struct{}{}, "__listOfInput": struct{}{}, "Output": struct{}{}, "InputDeviceActiveInput": struct{}{}, }, "MediaConvert": { "Input": struct{}{}, "__listOfOutput": struct{}{}, "Output": struct{}{}, "__listOfInput": struct{}{}, }, "MediaConnect": {"Output": struct{}{}, "__listOfOutput": struct{}{}}, "Lambda": { "LayerVersionContentOutput": struct{}{}, "LayerVersionContentInput": struct{}{}, }, "KinesisAnalyticsV2": { "KinesisStreamsInput": struct{}{}, "KinesisFirehoseInput": struct{}{}, "LambdaOutput": struct{}{}, "Output": struct{}{}, "KinesisFirehoseOutput": struct{}{}, "Input": struct{}{}, "KinesisStreamsOutput": struct{}{}, }, "KinesisAnalytics": { "Output": struct{}{}, "KinesisFirehoseInput": struct{}{}, "LambdaOutput": struct{}{}, "KinesisFirehoseOutput": struct{}{}, "KinesisStreamsInput": struct{}{}, "Input": struct{}{}, "KinesisStreamsOutput": struct{}{}, }, "IoTEvents": {"Input": struct{}{}}, "IoT": {"PutItemInput": struct{}{}}, "Honeycode": {"CellInput": struct{}{}, "RowDataInput": struct{}{}}, "Glue": { "TableInput": struct{}{}, "UserDefinedFunctionInput": struct{}{}, "DatabaseInput": struct{}{}, "PartitionInput": struct{}{}, "ConnectionInput": struct{}{}, }, "Glacier": { "CSVInput": struct{}{}, "CSVOutput": struct{}{}, "InventoryRetrievalJobInput": struct{}{}, }, "FIS": { "CreateExperimentTemplateTargetInput": struct{}{}, "CreateExperimentTemplateStopConditionInput": struct{}{}, "UpdateExperimentTemplateStopConditionInput": struct{}{}, "CreateExperimentTemplateActionInput": struct{}{}, "UpdateExperimentTemplateTargetInput": struct{}{}, }, "Firehose": {"DeliveryStreamEncryptionConfigurationInput": struct{}{}}, "CloudWatchEvents": {"TransformerInput": struct{}{}, "TargetInput": struct{}{}}, "EventBridge": {"TransformerInput": struct{}{}, "TargetInput": struct{}{}}, "ElasticsearchService": { "AutoTuneOptionsOutput": struct{}{}, "SAMLOptionsInput": struct{}{}, "AdvancedSecurityOptionsInput": struct{}{}, "SAMLOptionsOutput": struct{}{}, "AutoTuneOptionsInput": struct{}{}, }, "ElasticTranscoder": { "JobOutput": struct{}{}, "CreateJobOutput": struct{}{}, "JobInput": struct{}{}, }, "ElastiCache": { "UserGroupIdListInput": struct{}{}, "PasswordListInput": struct{}{}, "UserIdListInput": struct{}{}, }, "ECRPublic": {"RepositoryCatalogDataInput": struct{}{}}, "DeviceFarm": {"TestGridUrlExpiresInSecondsInput": struct{}{}}, "GlueDataBrew": {"Output": struct{}{}, "Input": struct{}{}, "OverwriteOutput": struct{}{}}, "CodePipeline": {"ActionExecutionInput": struct{}{}, "ActionExecutionOutput": struct{}{}}, "CodeBuild": {"ValueInput": struct{}{}, "KeyInput": struct{}{}}, "CloudFormation": {"Output": struct{}{}}, "Backup": { "PlanInput": struct{}{}, "RulesInput": struct{}{}, "RuleInput": struct{}{}, }, "ApplicationInsights": {"StatesInput": struct{}{}}, "ApiGatewayV2": { "TlsConfigInput": struct{}{}, "MutualTlsAuthenticationInput": struct{}{}, }, "APIGateway": {"MutualTlsAuthenticationInput": struct{}{}}, }	7.46 KB	2025-05-25 12:27
📄 legacy_jsonvalue.go //go:build codegen // +build codegen package api type legacyJSONValues struct { Type string StructMembers map[string]struct{} ListMemberRef bool MapValueRef bool } var legacyJSONValueShapes = map[string]map[string]legacyJSONValues{ "braket": map[string]legacyJSONValues{ "CreateQuantumTaskRequest": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "action": struct{}{}, "deviceParameters": struct{}{}, }, }, "GetDeviceResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "deviceCapabilities": struct{}{}, }, }, "GetQuantumTaskResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "deviceParameters": struct{}{}, }, }, }, "cloudwatchrum": map[string]legacyJSONValues{ "RumEvent": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "details": struct{}{}, "metadata": struct{}{}, }, }, }, "lexruntimeservice": map[string]legacyJSONValues{ "PostContentRequest": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "requestAttributes": struct{}{}, //"ActiveContexts": struct{}{}, - Disabled because JSON List "sessionAttributes": struct{}{}, }, }, "PostContentResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ // "alternativeIntents": struct{}{}, - Disabled because JSON List "sessionAttributes": struct{}{}, "nluIntentConfidence": struct{}{}, "slots": struct{}{}, //"activeContexts": struct{}{}, - Disabled because JSON List }, }, "PutSessionResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ // "activeContexts": struct{}{}, - Disabled because JSON List "slots": struct{}{}, "sessionAttributes": struct{}{}, }, }, }, "lookoutequipment": map[string]legacyJSONValues{ "DatasetSchema": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "InlineDataSchema": struct{}{}, }, }, "DescribeDatasetResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "Schema": struct{}{}, }, }, "DescribeModelResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "Schema": struct{}{}, "ModelMetrics": struct{}{}, }, }, }, "networkmanager": map[string]legacyJSONValues{ "CoreNetworkPolicy": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "PolicyDocument": struct{}{}, }, }, "GetResourcePolicyResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "PolicyDocument": struct{}{}, }, }, "PutCoreNetworkPolicyRequest": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "PolicyDocument": struct{}{}, }, }, "PutResourcePolicyRequest": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "PolicyDocument": struct{}{}, }, }, }, "personalizeevents": map[string]legacyJSONValues{ "Event": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "properties": struct{}{}, }, }, "Item": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "properties": struct{}{}, }, }, "User": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "properties": struct{}{}, }, }, }, "pricing": map[string]legacyJSONValues{ "PriceListJsonItems": legacyJSONValues{ Type: "list", ListMemberRef: true, }, }, "rekognition": map[string]legacyJSONValues{ "HumanLoopActivationOutput": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "HumanLoopActivationConditionsEvaluationResults": struct{}{}, }, }, }, "sagemaker": map[string]legacyJSONValues{ "HumanLoopActivationConditionsConfig": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "HumanLoopActivationConditions": struct{}{}, }, }, }, "schemas": map[string]legacyJSONValues{ "GetResourcePolicyResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "Policy": struct{}{}, }, }, "PutResourcePolicyRequest": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "Policy": struct{}{}, }, }, "PutResourcePolicyResponse": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "Policy": struct{}{}, }, }, "GetResourcePolicyOutput": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "Policy": struct{}{}, }, }, "PutResourcePolicyInput": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "Policy": struct{}{}, }, }, "PutResourcePolicyOutput": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "Policy": struct{}{}, }, }, }, "textract": map[string]legacyJSONValues{ "HumanLoopActivationOutput": legacyJSONValues{ Type: "structure", StructMembers: map[string]struct{}{ "HumanLoopActivationConditionsEvaluationResults": struct{}{}, }, }, }, }	5.21 KB	2025-05-25 12:27
📄 legacy_struct_names.go package api var legacyStructNames = map[string]string{ "accessanalyzer": "Access Analyzer", "account": "AWS Account", "acm": "ACM", "acm pca": "ACM-PCA", "alexa for business": "Alexa For Business", "amp": "Amazon Prometheus Service", "amplify": "Amplify", "amplifybackend": "AmplifyBackend", "amplifyuibuilder": "AWS Amplify UI Builder", "api gateway": "Amazon API Gateway", "apigatewaymanagementapi": "AmazonApiGatewayManagementApi", "apigatewayv2": "AmazonApiGatewayV2", "app mesh": "AWS App Mesh", "appconfig": "AppConfig", "appconfigdata": "AWS AppConfig Data", "appflow": "Amazon Appflow", "appintegrations": "Amazon AppIntegrations Service", "application auto scaling": "Application Auto Scaling", "application discovery service": "AWS Application Discovery Service", "application insights": "Application Insights", "applicationcostprofiler": "AWS Application Cost Profiler", "apprunner": "AWS App Runner", "appstream": "Amazon AppStream", "appsync": "AWSAppSync", "athena": "Amazon Athena", "auditmanager": "AWS Audit Manager", "auto scaling": "Auto Scaling", "auto scaling plans": "AWS Auto Scaling Plans", "backup": "AWS Backup", "backup gateway": "AWS Backup Gateway", "batch": "AWS Batch", "billingconductor": "AWSBillingConductor", "braket": "Braket", "budgets": "AWSBudgets", "chime": "Amazon Chime", "chime sdk identity": "Amazon Chime SDK Identity", "chime sdk media pipelines": "Amazon Chime SDK Media Pipelines", "chime sdk meetings": "Amazon Chime SDK Meetings", "chime sdk messaging": "Amazon Chime SDK Messaging", "cloud9": "AWS Cloud9", "cloudcontrol": "CloudControlApi", "clouddirectory": "Amazon CloudDirectory", "cloudformation": "AWS CloudFormation", "cloudfront": "CloudFront", "cloudhsm": "CloudHSM", "cloudhsm v2": "CloudHSM V2", "cloudsearch": "Amazon CloudSearch", "cloudsearch domain": "Amazon CloudSearch Domain", "cloudtrail": "CloudTrail", "cloudwatch": "CloudWatch", "cloudwatch events": "Amazon CloudWatch Events", "cloudwatch logs": "Amazon CloudWatch Logs", "codeartifact": "CodeArtifact", "codebuild": "AWS CodeBuild", "codecommit": "CodeCommit", "codedeploy": "CodeDeploy", "codeguru reviewer": "CodeGuruReviewer", "codeguruprofiler": "Amazon CodeGuru Profiler", "codepipeline": "CodePipeline", "codestar": "CodeStar", "codestar connections": "AWS CodeStar connections", "codestar notifications": "AWS CodeStar Notifications", "cognito identity": "Amazon Cognito Identity", "cognito identity provider": "Amazon Cognito Identity Provider", "cognito sync": "Amazon Cognito Sync", "comprehend": "Amazon Comprehend", "comprehendmedical": "ComprehendMedical", "compute optimizer": "AWS Compute Optimizer", "config service": "Config Service", "connect": "Amazon Connect", "connect contact lens": "Amazon Connect Contact Lens", "connectparticipant": "Amazon Connect Participant", "cost and usage report service": "AWS Cost and Usage Report Service", "cost explorer": "AWS Cost Explorer", "customer profiles": "Customer Profiles", "data pipeline": "AWS Data Pipeline", "database migration service": "AWS Database Migration Service", "databrew": "AWS Glue DataBrew", "dataexchange": "AWS Data Exchange", "datasync": "DataSync", "dax": "Amazon DAX", "detective": "Amazon Detective", "device farm": "AWS Device Farm", "devops guru": "Amazon DevOps Guru", "direct connect": "AWS Direct Connect", "directory service": "Directory Service", "dlm": "Amazon DLM", "docdb": "Amazon DocDB", "drs": "drs", "dynamodb": "DynamoDB", "dynamodb streams": "Amazon DynamoDB Streams", "ebs": "Amazon EBS", "ec2": "Amazon EC2", "ec2 instance connect": "EC2 Instance Connect", "ecr": "Amazon ECR", "ecr public": "Amazon ECR Public", "ecs": "Amazon ECS", "efs": "EFS", "eks": "Amazon EKS", "elastic beanstalk": "Elastic Beanstalk", "elastic inference": "Amazon Elastic Inference", "elastic load balancing": "Elastic Load Balancing", "elastic load balancing v2": "Elastic Load Balancing v2", "elastic transcoder": "Amazon Elastic Transcoder", "elasticache": "Amazon ElastiCache", "elasticsearch service": "Amazon Elasticsearch Service", "emr": "Amazon EMR", "emr containers": "Amazon EMR Containers", "emr serverless": "EMR Serverless", "eventbridge": "Amazon EventBridge", "evidently": "Amazon CloudWatch Evidently", "finspace": "finspace", "finspace data": "FinSpace Data", "firehose": "Firehose", "fis": "FIS", "fms": "FMS", "forecast": "Amazon Forecast Service", "forecastquery": "Amazon Forecast Query Service", "frauddetector": "Amazon Fraud Detector", "fsx": "Amazon FSx", "gamelift": "Amazon GameLift", "gamesparks": "GameSparks", "glacier": "Amazon Glacier", "global accelerator": "AWS Global Accelerator", "glue": "AWS Glue", "grafana": "Amazon Managed Grafana", "greengrass": "AWS Greengrass", "greengrassv2": "AWS GreengrassV2", "groundstation": "AWS Ground Station", "guardduty": "Amazon GuardDuty", "health": "AWSHealth", "healthlake": "HealthLake", "honeycode": "Honeycode", "iam": "IAM", "identitystore": "IdentityStore", "imagebuilder": "imagebuilder", "import export": "AWS Import/Export", "inspector": "Amazon Inspector", "inspector2": "Inspector2", "iot": "AWS IoT", "iot 1click devices service": "AWS IoT 1-Click Devices Service", "iot 1click projects": "AWS IoT 1-Click Projects", "iot data plane": "AWS IoT Data Plane", "iot events": "AWS IoT Events", "iot events data": "AWS IoT Events Data", "iot jobs data plane": "AWS IoT Jobs Data Plane", "iot wireless": "AWS IoT Wireless", "iotanalytics": "AWS IoT Analytics", "iotdeviceadvisor": "AWSIoTDeviceAdvisor", "iotfleethub": "AWS IoT Fleet Hub", "iotsecuretunneling": "AWS IoT Secure Tunneling", "iotsitewise": "AWS IoT SiteWise", "iotthingsgraph": "AWS IoT Things Graph", "iottwinmaker": "AWS IoT TwinMaker", "ivs": "Amazon IVS", "ivschat": "ivschat", "kafka": "Kafka", "kafkaconnect": "Kafka Connect", "kendra": "kendra", "keyspaces": "Amazon Keyspaces", "kinesis": "Kinesis", "kinesis analytics": "Kinesis Analytics", "kinesis analytics v2": "Kinesis Analytics V2", "kinesis video": "Kinesis Video", "kinesis video archived media": "Kinesis Video Archived Media", "kinesis video media": "Kinesis Video Media", "kinesis video signaling": "Amazon Kinesis Video Signaling Channels", "kms": "KMS", "lakeformation": "AWS Lake Formation", "lambda": "AWS Lambda", "lex model building service": "Amazon Lex Model Building Service", "lex models v2": "Lex Models V2", "lex runtime service": "Amazon Lex Runtime Service", "lex runtime v2": "Lex Runtime V2", "license manager": "AWS License Manager", "lightsail": "Amazon Lightsail", "location": "Amazon Location Service", "lookoutequipment": "LookoutEquipment", "lookoutmetrics": "LookoutMetrics", "lookoutvision": "Amazon Lookout for Vision", "machine learning": "Amazon Machine Learning", "macie": "Amazon Macie", "macie2": "Amazon Macie 2", "managedblockchain": "ManagedBlockchain", "marketplace catalog": "AWS Marketplace Catalog", "marketplace commerce analytics": "AWS Marketplace Commerce Analytics", "marketplace entitlement service": "AWS Marketplace Entitlement Service", "marketplace metering": "AWSMarketplace Metering", "mediaconnect": "AWS MediaConnect", "mediaconvert": "MediaConvert", "medialive": "MediaLive", "mediapackage": "MediaPackage", "mediapackage vod": "MediaPackage Vod", "mediastore": "MediaStore", "mediastore data": "MediaStore Data", "mediatailor": "MediaTailor", "memorydb": "Amazon MemoryDB", "mgn": "mgn", "migration hub": "AWS Migration Hub", "migration hub refactor spaces": "AWS Migration Hub Refactor Spaces", "migrationhub config": "AWS Migration Hub Config", "migrationhubstrategy": "Migration Hub Strategy Recommendations", "mobile": "AWS Mobile", "mobile analytics": "Amazon Mobile Analytics", "mq": "AmazonMQ", "mturk": "Amazon MTurk", "mwaa": "AmazonMWAA", "neptune": "Amazon Neptune", "network firewall": "Network Firewall", "networkmanager": "NetworkManager", "nimble": "AmazonNimbleStudio", "opensearch": "Amazon OpenSearch Service", "opsworks": "AWS OpsWorks", "opsworkscm": "OpsWorksCM", "organizations": "Organizations", "outposts": "Outposts", "panorama": "Panorama", "personalize": "Amazon Personalize", "personalize events": "Amazon Personalize Events", "personalize runtime": "Amazon Personalize Runtime", "pi": "AWS PI", "pinpoint": "Amazon Pinpoint", "pinpoint email": "Pinpoint Email", "pinpoint sms voice": "Pinpoint SMS Voice", "pinpoint sms voice v2": "Amazon Pinpoint SMS Voice V2", "polly": "Amazon Polly", "pricing": "AWS Pricing", "proton": "AWS Proton", "qldb": "QLDB", "qldb session": "QLDB Session", "quicksight": "Amazon QuickSight", "ram": "RAM", "rbin": "Amazon Recycle Bin", "rds": "Amazon RDS", "rds data": "AWS RDS DataService", "redshift": "Amazon Redshift", "redshift data": "Redshift Data API Service", "rekognition": "Amazon Rekognition", "resiliencehub": "AWS Resilience Hub", "resource groups": "Resource Groups", "resource groups tagging api": "AWS Resource Groups Tagging API", "robomaker": "RoboMaker", "route 53": "Route 53", "route 53 domains": "Amazon Route 53 Domains", "route53 recovery cluster": "Route53 Recovery Cluster", "route53 recovery control config": "AWS Route53 Recovery Control Config", "route53 recovery readiness": "AWS Route53 Recovery Readiness", "route53resolver": "Route53Resolver", "rum": "CloudWatch RUM", "s3": "Amazon S3", "s3 control": "AWS S3 Control", "s3outposts": "Amazon S3 Outposts", "sagemaker": "SageMaker", "sagemaker a2i runtime": "Amazon Augmented AI Runtime", "sagemaker edge": "Amazon Sagemaker Edge Manager", "sagemaker featurestore runtime": "Amazon SageMaker Feature Store Runtime", "sagemaker runtime": "Amazon SageMaker Runtime", "savingsplans": "AWSSavingsPlans", "schemas": "Schemas", "secrets manager": "AWS Secrets Manager", "securityhub": "AWS SecurityHub", "serverlessapplicationrepository": "AWSServerlessApplicationRepository", "service catalog": "AWS Service Catalog", "service catalog appregistry": "AppRegistry", "service quotas": "Service Quotas", "servicediscovery": "ServiceDiscovery", "ses": "Amazon SES", "sesv2": "Amazon SES V2", "sfn": "AWS SFN", "shield": "AWS Shield", "signer": "signer", "simpledb": "Amazon SimpleDB", "sms": "SMS", "snow device management": "AWS Snow Device Management", "snowball": "Amazon Snowball", "sns": "Amazon SNS", "sqs": "Amazon SQS", "ssm": "Amazon SSM", "ssm contacts": "SSM Contacts", "ssm incidents": "SSM Incidents", "sso": "SSO", "sso admin": "SSO Admin", "sso oidc": "SSO OIDC", "storage gateway": "AWS Storage Gateway", "sts": "AWS STS", "support": "AWS Support", "swf": "Amazon SWF", "synthetics": "Synthetics", "textract": "Amazon Textract", "timestream query": "Timestream Query", "timestream write": "Timestream Write", "transcribe": "Amazon Transcribe Service", "transcribe streaming": "Amazon Transcribe Streaming Service", "transfer": "AWS Transfer", "translate": "Amazon Translate", "voice id": "Amazon Voice ID", "waf": "WAF", "waf regional": "WAF Regional", "wafv2": "WAFV2", "wellarchitected": "Well-Architected", "wisdom": "Amazon Connect Wisdom Service", "workdocs": "Amazon WorkDocs", "worklink": "WorkLink", "workmail": "Amazon WorkMail", "workmailmessageflow": "Amazon WorkMail Message Flow", "workspaces": "Amazon WorkSpaces", "workspaces web": "Amazon WorkSpaces Web", "xray": "AWS X-Ray", }	16.98 KB	2025-05-25 12:27
📄 legacy_stutter.go package api type stutterNames struct { Operations map[string]string Shapes map[string]string ShapeOrder []string } var legacyStutterNames = map[string]stutterNames{ "WorkSpaces": { Shapes: map[string]string{ "WorkspacesIpGroup": "IpGroup", "WorkspacesIpGroupsList": "IpGroupsList", }, }, "WorkMail": { Shapes: map[string]string{ "WorkMailIdentifier": "Identifier", }, }, "WAF": { Shapes: map[string]string{ "WAFInvalidPermissionPolicyException": "InvalidPermissionPolicyException", "WAFInvalidOperationException": "InvalidOperationException", "WAFInternalErrorException": "InternalErrorException", "WAFDisallowedNameException": "DisallowedNameException", "WAFReferencedItemException": "ReferencedItemException", "WAFInvalidParameterException": "InvalidParameterException", "WAFLimitsExceededException": "LimitsExceededException", "WAFNonexistentContainerException": "NonexistentContainerException", "WAFInvalidAccountException": "InvalidAccountException", "WAFSubscriptionNotFoundException": "SubscriptionNotFoundException", "WAFBadRequestException": "BadRequestException", "WAFNonexistentItemException": "NonexistentItemException", "WAFServiceLinkedRoleErrorException": "ServiceLinkedRoleErrorException", "WAFNonEmptyEntityException": "NonEmptyEntityException", "WAFTagOperationInternalErrorException": "TagOperationInternalErrorException", "WAFStaleDataException": "StaleDataException", "WAFTagOperationException": "TagOperationException", "WAFInvalidRegexPatternException": "InvalidRegexPatternException", }, }, "Translate": { Operations: map[string]string{ "TranslateText": "Text", }, Shapes: map[string]string{ "TranslateTextRequest": "TextRequest", "TranslateTextResponse": "TextResponse", }, }, "Storage Gateway": { Shapes: map[string]string{ "StorageGatewayError": "Error", }, }, "Snowball": { Shapes: map[string]string{ "SnowballType": "Type", "SnowballCapacity": "Capacity", }, }, "S3": { Shapes: map[string]string{ "S3KeyFilter": "KeyFilter", "S3Location": "Location", }, }, "Rekognition": { Shapes: map[string]string{ "RekognitionUniqueId": "UniqueId", }, }, "QuickSight": { Shapes: map[string]string{ "QuickSightUserNotFoundException": "UserNotFoundException", }, }, "Marketplace Commerce Analytics": { Shapes: map[string]string{ "MarketplaceCommerceAnalyticsException": "Exception", }, }, "KMS": { Shapes: map[string]string{ "KMSInternalException": "InternalException", "KMSInvalidStateException": "InvalidStateException", }, }, "Kinesis Analytics": { Shapes: map[string]string{ "KinesisAnalyticsARN": "ARN", }, }, "IoT Events": { ShapeOrder: []string{ "Action", "IotEventsAction", }, Shapes: map[string]string{ "Action": "ActionData", "IotEventsAction": "Action", }, }, "Inspector": { Shapes: map[string]string{ "InspectorServiceAttributes": "ServiceAttributes", "InspectorEvent": "Event", }, }, "GuardDuty": { Shapes: map[string]string{ "GuardDutyArn": "Arn", }, }, "GroundStation": { Shapes: map[string]string{ "GroundStationList": "List", "GroundStationData": "Data", }, }, "Glue": { ShapeOrder: []string{ "Table", "GlueTable", "GlueTables", "GlueResourceArn", "GlueEncryptionException", }, Shapes: map[string]string{ "Table": "TableData", "GlueTable": "Table", "GlueTables": "Tables", "GlueResourceArn": "ResourceArn", "GlueEncryptionException": "EncryptionException", }, }, "Glacier": { Shapes: map[string]string{ "GlacierJobDescription": "JobDescription", }, }, "Elastic Beanstalk": { Shapes: map[string]string{ "ElasticBeanstalkServiceException": "ServiceException", }, }, "Direct Connect": { Shapes: map[string]string{ "DirectConnectClientException": "ClientException", "DirectConnectGatewayAssociationProposalId": "GatewayAssociationProposalId", "DirectConnectGatewayAssociationProposalState": "GatewayAssociationProposalState", "DirectConnectGatewayAttachmentType": "GatewayAttachmentType", "DirectConnectGatewayAttachmentList": "GatewayAttachmentList", "DirectConnectGatewayAssociationProposalList": "GatewayAssociationProposalList", "DirectConnectGatewayAssociationId": "GatewayAssociationId", "DirectConnectGatewayList": "GatewayList", "DirectConnectGatewayName": "GatewayName", "DirectConnectGatewayAttachment": "GatewayAttachment", "DirectConnectServerException": "ServerException", "DirectConnectGatewayState": "GatewayState", "DirectConnectGateway": "Gateway", "DirectConnectGatewayId": "GatewayId", "DirectConnectGatewayAttachmentState": "GatewayAttachmentState", "DirectConnectGatewayAssociation": "GatewayAssociation", "DirectConnectGatewayAssociationProposal": "GatewayAssociationProposal", "DirectConnectGatewayAssociationState": "GatewayAssociationState", "DirectConnectGatewayAssociationList": "GatewayAssociationList", }, }, "Comprehend": { Shapes: map[string]string{ "ComprehendArnName": "ArnName", "ComprehendArn": "Arn", }, }, "Cognito Identity": { Shapes: map[string]string{ "CognitoIdentityProviderList": "ProviderList", "CognitoIdentityProviderName": "ProviderName", "CognitoIdentityProviderClientId": "ProviderClientId", "CognitoIdentityProviderTokenCheck": "ProviderTokenCheck", "CognitoIdentityProvider": "Provider", }, }, "CloudTrail": { Shapes: map[string]string{ "CloudTrailAccessNotEnabledException": "AccessNotEnabledException", "CloudTrailARNInvalidException": "ARNInvalidException", }, }, "CloudFront": { Shapes: map[string]string{ "CloudFrontOriginAccessIdentitySummaryList": "OriginAccessIdentitySummaryList", "CloudFrontOriginAccessIdentity": "OriginAccessIdentity", "CloudFrontOriginAccessIdentityAlreadyExists": "OriginAccessIdentityAlreadyExists", "CloudFrontOriginAccessIdentityConfig": "OriginAccessIdentityConfig", "CloudFrontOriginAccessIdentitySummary": "OriginAccessIdentitySummary", "CloudFrontOriginAccessIdentityList": "OriginAccessIdentityList", "CloudFrontOriginAccessIdentityInUse": "OriginAccessIdentityInUse", }, }, "Backup": { Shapes: map[string]string{ "BackupPlan": "Plan", "BackupRule": "Rule", "BackupSelectionName": "SelectionName", "BackupSelectionsList": "SelectionsList", "BackupVaultEvents": "VaultEvents", "BackupRuleName": "RuleName", "BackupVaultName": "VaultName", "BackupJob": "Job", "BackupJobState": "JobState", "BackupJobsList": "JobsList", "BackupVaultEvent": "VaultEvent", "BackupPlanVersionsList": "PlanVersionsList", "BackupPlansListMember": "PlansListMember", "BackupSelection": "Selection", "BackupVaultList": "VaultList", "BackupVaultListMember": "VaultListMember", "BackupPlanInput": "PlanInput", "BackupRules": "Rules", "BackupPlansList": "PlansList", "BackupPlanTemplatesList": "PlanTemplatesList", "BackupRuleInput": "RuleInput", "BackupPlanTemplatesListMember": "PlanTemplatesListMember", "BackupRulesInput": "RulesInput", "BackupSelectionsListMember": "SelectionsListMember", "BackupPlanName": "PlanName", }, }, "Auto Scaling": { Shapes: map[string]string{ "AutoScalingGroupDesiredCapacity": "GroupDesiredCapacity", "AutoScalingGroupNames": "GroupNames", "AutoScalingGroupsType": "GroupsType", "AutoScalingNotificationTypes": "NotificationTypes", "AutoScalingGroupNamesType": "GroupNamesType", "AutoScalingInstancesType": "InstancesType", "AutoScalingInstanceDetails": "InstanceDetails", "AutoScalingGroupMaxSize": "GroupMaxSize", "AutoScalingGroups": "Groups", "AutoScalingGroupMinSize": "GroupMinSize", "AutoScalingGroup": "Group", }, }, "AppStream": { Shapes: map[string]string{ "AppstreamAgentVersion": "AgentVersion", }, }, }	8.65 KB	2025-05-25 12:27
📄 list_of_shame.go package api type persistAPIType struct { output bool input bool } type persistAPITypes map[string]map[string]persistAPIType func (ts persistAPITypes) Lookup(serviceName, opName string) persistAPIType { service, ok := shamelist[serviceName] if !ok { return persistAPIType{} } return service[opName] } func (ts persistAPITypes) Input(serviceName, opName string) bool { return ts.Lookup(serviceName, opName).input } func (ts persistAPITypes) Output(serviceName, opName string) bool { return ts.Lookup(serviceName, opName).output } // shamelist is used to not rename certain operation's input and output shapes. // We need to maintain backwards compatibility with pre-existing services. Since // not generating unique input/output shapes is not desired, we will generate // unique input/output shapes for new operations. var shamelist = persistAPITypes{ "APIGateway": { "CreateApiKey": { output: true, }, "CreateAuthorizer": { output: true, }, "CreateBasePathMapping": { output: true, }, "CreateDeployment": { output: true, }, "CreateDocumentationPart": { output: true, }, "CreateDocumentationVersion": { output: true, }, "CreateDomainName": { output: true, }, "CreateModel": { output: true, }, "CreateResource": { output: true, }, "CreateRestApi": { output: true, }, "CreateStage": { output: true, }, "CreateUsagePlan": { output: true, }, "CreateUsagePlanKey": { output: true, }, "GenerateClientCertificate": { output: true, }, "GetAccount": { output: true, }, "GetApiKey": { output: true, }, "GetAuthorizer": { output: true, }, "GetBasePathMapping": { output: true, }, "GetClientCertificate": { output: true, }, "GetDeployment": { output: true, }, "GetDocumentationPart": { output: true, }, "GetDocumentationVersion": { output: true, }, "GetDomainName": { output: true, }, "GetIntegration": { output: true, }, "GetIntegrationResponse": { output: true, }, "GetMethod": { output: true, }, "GetMethodResponse": { output: true, }, "GetModel": { output: true, }, "GetResource": { output: true, }, "GetRestApi": { output: true, }, "GetSdkType": { output: true, }, "GetStage": { output: true, }, "GetUsage": { output: true, }, "GetUsagePlan": { output: true, }, "GetUsagePlanKey": { output: true, }, "ImportRestApi": { output: true, }, "PutIntegration": { output: true, }, "PutIntegrationResponse": { output: true, }, "PutMethod": { output: true, }, "PutMethodResponse": { output: true, }, "PutRestApi": { output: true, }, "UpdateAccount": { output: true, }, "UpdateApiKey": { output: true, }, "UpdateAuthorizer": { output: true, }, "UpdateBasePathMapping": { output: true, }, "UpdateClientCertificate": { output: true, }, "UpdateDeployment": { output: true, }, "UpdateDocumentationPart": { output: true, }, "UpdateDocumentationVersion": { output: true, }, "UpdateDomainName": { output: true, }, "UpdateIntegration": { output: true, }, "UpdateIntegrationResponse": { output: true, }, "UpdateMethod": { output: true, }, "UpdateMethodResponse": { output: true, }, "UpdateModel": { output: true, }, "UpdateResource": { output: true, }, "UpdateRestApi": { output: true, }, "UpdateStage": { output: true, }, "UpdateUsage": { output: true, }, "UpdateUsagePlan": { output: true, }, }, "AutoScaling": { "ResumeProcesses": { input: true, }, "SuspendProcesses": { input: true, }, }, "CognitoIdentity": { "CreateIdentityPool": { output: true, }, "DescribeIdentity": { output: true, }, "DescribeIdentityPool": { output: true, }, "UpdateIdentityPool": { input: true, output: true, }, }, "DirectConnect": { "AllocateConnectionOnInterconnect": { output: true, }, "AllocateHostedConnection": { output: true, }, "AllocatePrivateVirtualInterface": { output: true, }, "AllocatePublicVirtualInterface": { output: true, }, "AssociateConnectionWithLag": { output: true, }, "AssociateHostedConnection": { output: true, }, "AssociateVirtualInterface": { output: true, }, "CreateConnection": { output: true, }, "CreateInterconnect": { output: true, }, "CreateLag": { output: true, }, "CreatePrivateVirtualInterface": { output: true, }, "CreatePublicVirtualInterface": { output: true, }, "DeleteConnection": { output: true, }, "DeleteLag": { output: true, }, "DescribeConnections": { output: true, }, "DescribeConnectionsOnInterconnect": { output: true, }, "DescribeHostedConnections": { output: true, }, "DescribeLoa": { output: true, }, "DisassociateConnectionFromLag": { output: true, }, "UpdateLag": { output: true, }, }, "EC2": { "AttachVolume": { output: true, }, "CreateSnapshot": { output: true, }, "CreateVolume": { output: true, }, "DetachVolume": { output: true, }, "RunInstances": { output: true, }, }, "EFS": { "CreateFileSystem": { output: true, }, "CreateMountTarget": { output: true, }, }, "ElastiCache": { "AddTagsToResource": { output: true, }, "ListTagsForResource": { output: true, }, "ModifyCacheParameterGroup": { output: true, }, "RemoveTagsFromResource": { output: true, }, "ResetCacheParameterGroup": { output: true, }, }, "ElasticBeanstalk": { "ComposeEnvironments": { output: true, }, "CreateApplication": { output: true, }, "CreateApplicationVersion": { output: true, }, "CreateConfigurationTemplate": { output: true, }, "CreateEnvironment": { output: true, }, "DescribeEnvironments": { output: true, }, "TerminateEnvironment": { output: true, }, "UpdateApplication": { output: true, }, "UpdateApplicationVersion": { output: true, }, "UpdateConfigurationTemplate": { output: true, }, "UpdateEnvironment": { output: true, }, }, "ElasticTranscoder": { "CreateJob": { output: true, }, }, "Glacier": { "DescribeJob": { output: true, }, "UploadArchive": { output: true, }, "CompleteMultipartUpload": { output: true, }, }, "IAM": { "GetContextKeysForCustomPolicy": { output: true, }, "GetContextKeysForPrincipalPolicy": { output: true, }, "SimulateCustomPolicy": { output: true, }, "SimulatePrincipalPolicy": { output: true, }, }, "Kinesis": { "DisableEnhancedMonitoring": { output: true, }, "EnableEnhancedMonitoring": { output: true, }, }, "KMS": { "ListGrants": { output: true, }, "ListRetirableGrants": { output: true, }, }, "Lambda": { "CreateAlias": { output: true, }, "CreateEventSourceMapping": { output: true, }, "CreateFunction": { output: true, }, "DeleteEventSourceMapping": { output: true, }, "GetAlias": { output: true, }, "GetEventSourceMapping": { output: true, }, "GetFunctionConfiguration": { output: true, }, "PublishVersion": { output: true, }, "UpdateAlias": { output: true, }, "UpdateEventSourceMapping": { output: true, }, "UpdateFunctionCode": { output: true, }, "UpdateFunctionConfiguration": { output: true, }, }, "MQ": { "CreateBroker": { input: true, output: true, }, "CreateConfiguration": { input: true, output: true, }, "CreateUser": { input: true, }, "DeleteBroker": { output: true, }, "DescribeBroker": { output: true, }, "DescribeUser": { output: true, }, "DescribeConfigurationRevision": { output: true, }, "ListBrokers": { output: true, }, "ListConfigurations": { output: true, }, "ListConfigurationRevisions": { output: true, }, "ListUsers": { output: true, }, "UpdateBroker": { input: true, output: true, }, "UpdateConfiguration": { input: true, output: true, }, "UpdateUser": { input: true, }, }, "RDS": { "ModifyDBClusterParameterGroup": { output: true, }, "ModifyDBParameterGroup": { output: true, }, "ResetDBClusterParameterGroup": { output: true, }, "ResetDBParameterGroup": { output: true, }, }, "Redshift": { "DescribeLoggingStatus": { output: true, }, "DisableLogging": { output: true, }, "EnableLogging": { output: true, }, "ModifyClusterParameterGroup": { output: true, }, "ResetClusterParameterGroup": { output: true, }, }, "S3": { "GetBucketNotification": { input: true, output: true, }, "GetBucketNotificationConfiguration": { input: true, output: true, }, }, "ServerlessApplicationRepository": { "CreateApplication": { input: true, }, "CreateApplicationVersion": { input: true, }, "CreateCloudFormationChangeSet": { input: true, }, "UpdateApplication": { input: true, }, }, "SWF": { "CountClosedWorkflowExecutions": { output: true, }, "CountOpenWorkflowExecutions": { output: true, }, "CountPendingActivityTasks": { output: true, }, "CountPendingDecisionTasks": { output: true, }, "ListClosedWorkflowExecutions": { output: true, }, "ListOpenWorkflowExecutions": { output: true, }, }, }	9.26 KB	2025-05-25 12:27
📄 load.go //go:build codegen // +build codegen package api import ( "encoding/json" "fmt" "log" "os" "path/filepath" "sort" "strings" ) // APIs provides a set of API models loaded by API package name. type APIs map[string]API // Loader provides the loading of APIs from files. type Loader struct { // The base Go import path the loaded models will be appended to. BaseImport string // Allows ignoring API models that are unsupported by the SDK without // failing the load of other supported APIs. IgnoreUnsupportedAPIs bool // Set to true to strictly enforce usage of the serviceId for the package naming StrictServiceId bool } // Load loads the API model files from disk returning the map of API package. // Returns error if multiple API model resolve to the same package name. func (l Loader) Load(modelPaths []string) (APIs, error) { apis := APIs{} for _, modelPath := range modelPaths { a, err := loadAPI(modelPath, l.BaseImport, func(a API) { a.IgnoreUnsupportedAPIs = l.IgnoreUnsupportedAPIs a.StrictServiceId = l.StrictServiceId }) if err != nil { return nil, fmt.Errorf("failed to load API, %v, %v", modelPath, err) } if len(a.Operations) == 0 { if l.IgnoreUnsupportedAPIs { fmt.Fprintf(os.Stderr, "API has no operations, ignoring model %s, %v\n", modelPath, a.ImportPath()) continue } } importPath := a.ImportPath() if _, ok := apis[importPath]; ok { return nil, fmt.Errorf( "package names must be unique attempted to load %v twice. Second model file: %v", importPath, modelPath) } apis[importPath] = a } return apis, nil } // attempts to load a model from disk into the import specified. Additional API // options are invoked before to the API's Setup being called. func loadAPI(modelPath, baseImport string, opts ...func(API)) (API, error) { a := &API{ BaseImportPath: baseImport, BaseCrosslinkURL: "https://docs.aws.amazon.com", } for _, opt := range opts { opt(a) } modelFile := filepath.Base(modelPath) modelDir := filepath.Dir(modelPath) err := attachModelFiles(modelDir, modelLoader{modelFile, a.Attach, true}, modelLoader{"docs-2.json", a.AttachDocs, false}, modelLoader{"paginators-1.json", a.AttachPaginators, false}, modelLoader{"waiters-2.json", a.AttachWaiters, false}, modelLoader{"examples-1.json", a.AttachExamples, false}, modelLoader{"smoke.json", a.AttachSmokeTests, false}, ) if err != nil { return nil, err } if err = a.Setup(); err != nil { return nil, err } return a, nil } type modelLoader struct { Filename string Loader func(string) error Required bool } func attachModelFiles(modelPath string, modelFiles ...modelLoader) error { for _, m := range modelFiles { filepath := filepath.Join(modelPath, m.Filename) _, err := os.Stat(filepath) if os.IsNotExist(err) && !m.Required { continue } else if err != nil { return fmt.Errorf("failed to load model file %v, %v", m.Filename, err) } if err = m.Loader(filepath); err != nil { return fmt.Errorf("model load failed, %s, %v", modelPath, err) } } return nil } // ExpandModelGlobPath returns a slice of model paths expanded from the glob // pattern passed in. Returns the path of the model file to be loaded. Includes // all versions of a service model. // // e.g: // models/apis///api-2.json // // Or with specific model file: // models/apis/service/version/api-2.json func ExpandModelGlobPath(globs ...string) ([]string, error) { modelPaths := []string{} for _, g := range globs { filepaths, err := filepath.Glob(g) if err != nil { return nil, err } for _, p := range filepaths { modelPaths = append(modelPaths, p) } } return modelPaths, nil } // TrimModelServiceVersions sorts the model paths by service version then // returns recent model versions, and model version excluded. // // Uses the third from last path element to determine unique service. Only one // service version will be included. // // models/apis/service/version/api-2.json func TrimModelServiceVersions(modelPaths []string) (include, exclude []string) { sort.Strings(modelPaths) // Remove old API versions from list m := map[string]struct{}{} for i := len(modelPaths) - 1; i >= 0; i-- { // service name is 2nd-to-last component parts := strings.Split(modelPaths[i], string(filepath.Separator)) svc := parts[len(parts)-3] if _, ok := m[svc]; ok { // Removed unused service version exclude = append(exclude, modelPaths[i]) continue } include = append(include, modelPaths[i]) m[svc] = struct{}{} } return include, exclude } // Attach opens a file by name, and unmarshal its JSON data. // Will proceed to setup the API if not already done so. func (a API) Attach(filename string) error { a.path = filepath.Dir(filename) f, err := os.Open(filename) if err != nil { return err } defer f.Close() if err := json.NewDecoder(f).Decode(a); err != nil { return fmt.Errorf("failed to decode %s, err: %v", filename, err) } return nil } // AttachString will unmarshal a raw JSON string, and setup the // API if not already done so. func (a API) AttachString(str string) error { json.Unmarshal([]byte(str), a) if a.initialized { return nil } return a.Setup() } // Setup initializes the API. func (a *API) Setup() error { if err := a.validateNoDocumentShapes(); err != nil { return err } if !a.NoRemoveUnsupportedJSONValue { if err := removeUnsupportedJSONValue(a); err != nil { return fmt.Errorf("failed to remove unsupported JSONValue from API, %v", err) } } a.setServiceAliaseName() a.setMetadataEndpointsKey() a.writeShapeNames() a.resolveReferences() a.backfillErrorMembers() a.backfillSigningName() if !a.NoRemoveUnusedShapes { a.removeUnusedShapes() } a.fixStutterNames() if err := a.validateShapeNames(); err != nil { log.Fatalf(err.Error()) } a.renameExportable() a.applyShapeNameAliases() a.renameIOSuffixedShapeNames() a.createInputOutputShapes() a.writeInputOutputLocationName() a.renameAPIPayloadShapes() a.renameCollidingFields() a.updateTopLevelShapeReferences() if err := a.setupEventStreams(); err != nil { return err } a.findEndpointDiscoveryOp() a.injectUnboundedOutputStreaming() // Enables generated types for APIs using REST-JSON and JSONRPC protocols. // Other protocols will be added as supported. a.enableGeneratedTypedErrors() if err := a.customizationPasses(); err != nil { return err } a.addHeaderMapDocumentation() if !a.NoRemoveUnusedShapes { a.removeUnusedShapes() } if !a.NoValidataShapeMethods { a.addShapeValidations() } a.initialized = true return nil } // UnsupportedAPIModelError provides wrapping of an error causing the API to // fail to load because the SDK does not support the API service defined. type UnsupportedAPIModelError struct { Err error } func (e UnsupportedAPIModelError) Error() string { return fmt.Sprintf("service API is not supported, %v", e.Err) }	6.8 KB	2025-05-25 12:27
📄 load_test.go //go:build codegen // +build codegen package api import ( "path/filepath" "reflect" "strconv" "testing" ) func TestResolvedReferences(t testing.T) { json := `{ "operations": { "OperationName": { "input": { "shape": "TestName" } } }, "shapes": { "TestName": { "type": "structure", "members": { "memberName1": { "shape": "OtherTest" }, "memberName2": { "shape": "OtherTest" } } }, "OtherTest": { "type": "string" } } }` a := API{} a.AttachString(json) if len(a.Shapes["OtherTest"].refs) != 2 { t.Errorf("Expected %d, but received %d", 2, len(a.Shapes["OtherTest"].refs)) } } func TestTrimModelServiceVersions(t testing.T) { cases := []struct { Paths []string Include []string Exclude []string }{ { Paths: []string{ filepath.Join("foo", "baz", "2018-01-02", "api-2.json"), filepath.Join("foo", "baz", "2019-01-02", "api-2.json"), filepath.Join("foo", "baz", "2017-01-02", "api-2.json"), filepath.Join("foo", "bar", "2019-01-02", "api-2.json"), filepath.Join("foo", "bar", "2013-04-02", "api-2.json"), filepath.Join("foo", "bar", "2019-01-03", "api-2.json"), }, Include: []string{ filepath.Join("foo", "baz", "2019-01-02", "api-2.json"), filepath.Join("foo", "bar", "2019-01-03", "api-2.json"), }, Exclude: []string{ filepath.Join("foo", "baz", "2018-01-02", "api-2.json"), filepath.Join("foo", "baz", "2017-01-02", "api-2.json"), filepath.Join("foo", "bar", "2019-01-02", "api-2.json"), filepath.Join("foo", "bar", "2013-04-02", "api-2.json"), }, }, } for i, c := range cases { t.Run(strconv.Itoa(i), func(t *testing.T) { include, exclude := TrimModelServiceVersions(c.Paths) if e, a := c.Include, include; !reflect.DeepEqual(e, a) { t.Errorf("expect include %v, got %v", e, a) } if e, a := c.Exclude, exclude; !reflect.DeepEqual(e, a) { t.Errorf("expect exclude %v, got %v", e, a) } }) } }	1.92 KB	2025-05-25 12:27
📄 logger.go //go:build codegen // +build codegen package api import ( "fmt" "io" "sync" ) var debugLogger logger var initDebugLoggerOnce sync.Once // logger provides a basic logging type logger struct { w io.Writer } // LogDebug initialize's the debug logger for the components in the api // package to log debug lines to. // // Panics if called multiple times. // // Must be used prior to any model loading or code gen. func LogDebug(w io.Writer) { var initialized bool initDebugLoggerOnce.Do(func() { debugLogger = &logger{ w: w, } initialized = true }) if !initialized && debugLogger != nil { panic("LogDebug called multiple times. Can only be called once") } } // Logf logs using the fmt printf pattern. Appends a new line to the end of the // logged statement. func (l logger) Logf(format string, args ...interface{}) { if l == nil { return } fmt.Fprintf(l.w, format+"\n", args...) } // Logln logs using the fmt println pattern. func (l *logger) Logln(args ...interface{}) { if l == nil { return } fmt.Fprintln(l.w, args...) }	1.04 KB	2025-05-25 12:27
📄 operation.go //go:build codegen // +build codegen package api import ( "bytes" "fmt" "regexp" "sort" "strings" "text/template" ) // An Operation defines a specific API Operation. type Operation struct { API API `json:"-"` ExportedName string Name string Documentation string `json:"-"` HTTP HTTPInfo Host string `json:"host"` InputRef ShapeRef `json:"input"` OutputRef ShapeRef `json:"output"` ErrorRefs []ShapeRef `json:"errors"` Paginator Paginator Deprecated bool `json:"deprecated"` DeprecatedMsg string `json:"deprecatedMessage"` AuthType AuthType `json:"authtype"` imports map[string]bool CustomBuildHandlers []string EventStreamAPI EventStreamAPI IsEndpointDiscoveryOp bool `json:"endpointoperation"` EndpointDiscovery EndpointDiscovery `json:"endpointdiscovery"` Endpoint EndpointTrait `json:"endpoint"` // HTTPChecksum replaces usage of httpChecksumRequired, but some APIs // (s3control) still uses old trait. HTTPChecksum HTTPChecksum `json:"httpChecksum"` IsHttpChecksumRequired bool `json:"httpChecksumRequired"` } type HTTPChecksum struct { RequestAlgorithmMember string `json:"requestAlgorithmMember"` RequestValidationModeMember string `json:"requestValidationModeMember"` RequestChecksumRequired bool `json:"requestChecksumRequired"` } // RequestChecksumRequired returns if the request requires the Content-MD5 // checksum to be computed. func (o Operation) RequestChecksumRequired() bool { return o.HTTPChecksum.RequestChecksumRequired \|\| o.IsHttpChecksumRequired } // EndpointTrait provides the structure of the modeled endpoint trait, and its // properties. type EndpointTrait struct { // Specifies the hostPrefix template to prepend to the operation's request // endpoint host. HostPrefix string `json:"hostPrefix"` } // EndpointDiscovery represents a map of key values pairs that represents // metadata about how a given API will make a call to the discovery endpoint. type EndpointDiscovery struct { // Required indicates that for a given operation that endpoint is required. // Any required endpoint discovery operation cannot have endpoint discovery // turned off. Required bool `json:"required"` } // OperationForMethod returns the API operation name that corresponds to the // client method name provided. func (a API) OperationForMethod(name string) Operation { for _, op := range a.Operations { for _, m := range op.Methods() { if m == name { return op } } } return nil } // A HTTPInfo defines the method of HTTP request for the Operation. type HTTPInfo struct { Method string RequestURI string ResponseCode uint } // Methods Returns a list of method names that will be generated. func (o Operation) Methods() []string { methods := []string{ o.ExportedName, o.ExportedName + "Request", o.ExportedName + "WithContext", } if o.Paginator != nil { methods = append(methods, []string{ o.ExportedName + "Pages", o.ExportedName + "PagesWithContext", }...) } return methods } // HasInput returns if the Operation accepts an input parameter func (o Operation) HasInput() bool { return o.InputRef.ShapeName != "" } // HasOutput returns if the Operation accepts an output parameter func (o Operation) HasOutput() bool { return o.OutputRef.ShapeName != "" } // AuthType provides the enumeration of AuthType trait. type AuthType string // Enumeration values for AuthType trait const ( NoneAuthType AuthType = "none" V4UnsignedBodyAuthType AuthType = "v4-unsigned-body" ) // ShouldSignRequestBody returns if the operation request body should be signed // or not. func (o Operation) ShouldSignRequestBody() bool { switch o.AuthType { case NoneAuthType, V4UnsignedBodyAuthType: return false default: return true } } // GetSigner returns the signer that should be used for a API request. func (o Operation) GetSigner() string { buf := bytes.NewBuffer(nil) switch o.AuthType { case NoneAuthType: o.API.AddSDKImport("aws/credentials") buf.WriteString("req.Config.Credentials = credentials.AnonymousCredentials") case V4UnsignedBodyAuthType: o.API.AddSDKImport("aws/signer/v4") buf.WriteString("req.Handlers.Sign.Remove(v4.SignRequestHandler)\n") buf.WriteString("handler := v4.BuildNamedHandler(\"v4.CustomSignerHandler\", v4.WithUnsignedPayload)\n") buf.WriteString("req.Handlers.Sign.PushFrontNamed(handler)") } return buf.String() } // HasAccountIDMemberWithARN returns true if an account id member exists for an input shape that may take in an ARN. func (o Operation) HasAccountIDMemberWithARN() bool { return o.InputRef.Shape.HasAccountIdMemberWithARN } // operationTmpl defines a template for rendering an API Operation var operationTmpl = template.Must(template.New("operation").Funcs(template.FuncMap{ "EnableStopOnSameToken": enableStopOnSameToken, "GetDeprecatedMsg": getDeprecatedMessage, }).Parse(` const op{{ .ExportedName }} = "{{ .Name }}" // {{ .ExportedName }}Request generates a "aws/request.Request" representing the // client's request for the {{ .ExportedName }} operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See {{ .ExportedName }} for more information on using the {{ .ExportedName }} // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // // Example sending a request using the {{ .ExportedName }}Request method. // req, resp := client.{{ .ExportedName }}Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } {{ $crosslinkURL := $.API.GetCrosslinkURL $.ExportedName -}} {{ if ne $crosslinkURL "" -}} // // See also, {{ $crosslinkURL }} {{ end -}} {{- if .Deprecated }}// // Deprecated: {{ GetDeprecatedMsg .DeprecatedMsg .ExportedName }} {{ end -}} func (c {{ .API.StructName }}) {{ .ExportedName }}Request(` + `input {{ .InputRef.GoType }}) (req request.Request, output {{ .OutputRef.GoType }}) { {{ if (or .Deprecated (or .InputRef.Deprecated .OutputRef.Deprecated)) }}if c.Client.Config.Logger != nil { c.Client.Config.Logger.Log("This operation, {{ .ExportedName }}, has been deprecated") } op := &request.Operation{ {{ else }} op := &request.Operation{ {{ end }} Name: op{{ .ExportedName }}, {{ if ne .HTTP.Method "" }}HTTPMethod: "{{ .HTTP.Method }}", {{ end }}HTTPPath: {{ if ne .HTTP.RequestURI "" }}"{{ .HTTP.RequestURI }}"{{ else }}"/"{{ end }}, {{ if .Paginator }}Paginator: &request.Paginator{ InputTokens: {{ .Paginator.InputTokensString }}, OutputTokens: {{ .Paginator.OutputTokensString }}, LimitToken: "{{ .Paginator.LimitKey }}", TruncationToken: "{{ .Paginator.MoreResults }}", }, {{ end }} } if input == nil { input = &{{ .InputRef.GoTypeElem }}{} } output = &{{ .OutputRef.GoTypeElem }}{} req = c.newRequest(op, input, output) {{- if ne .AuthType "" }} {{ .GetSigner }} {{- end }} {{- if .HasAccountIDMemberWithARN }} // update account id or check if provided input for account id member matches // the account id present in ARN req.Handlers.Validate.PushFrontNamed(updateAccountIDWithARNHandler) {{- end }} {{- if .ShouldDiscardResponse -}} {{- $_ := .API.AddSDKImport "private/protocol" }} {{- $_ := .API.AddSDKImport "private/protocol" .API.ProtocolPackage }} req.Handlers.Unmarshal.Swap({{ .API.ProtocolPackage }}.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) {{- else }} {{- if $.EventStreamAPI }} {{- $esapi := $.EventStreamAPI }} {{- if $esapi.RequireHTTP2 }} req.Handlers.UnmarshalMeta.PushBack( protocol.RequireHTTPMinProtocol{Major:2}.Handler, ) {{- end }} es := New{{ $esapi.Name }}() {{- if $esapi.Legacy }} req.Handlers.Unmarshal.PushBack(es.setStreamCloser) {{- end }} output.{{ $esapi.OutputMemberName }} = es {{- $inputStream := $esapi.InputStream }} {{- $outputStream := $esapi.OutputStream }} {{- $_ := .API.AddSDKImport "private/protocol" .API.ProtocolPackage }} {{- $_ := .API.AddSDKImport "private/protocol/rest" }} {{- if $inputStream }} req.Handlers.Sign.PushFront(es.setupInputPipe) req.Handlers.UnmarshalError.PushBackNamed(request.NamedHandler{ Name: "InputPipeCloser", Fn: func (r request.Request) { err := es.closeInputPipe() if err != nil { r.Error = awserr.New(eventstreamapi.InputWriterCloseErrorCode, err.Error(), r.Error) } }, }) req.Handlers.Build.PushBack(request.WithSetRequestHeaders(map[string]string{ "Content-Type": "application/vnd.amazon.eventstream", "X-Amz-Content-Sha256": "STREAMING-AWS4-HMAC-SHA256-EVENTS", })) req.Handlers.Build.Swap({{ .API.ProtocolPackage }}.BuildHandler.Name, rest.BuildHandler) eventstreamapi.ApplyHTTPTransportFixes(req) req.Handlers.Send.Swap(client.LogHTTPRequestHandler.Name, client.LogHTTPRequestHeaderHandler) req.Handlers.Unmarshal.PushBack(es.runInputStream) {{- if eq .API.Metadata.Protocol "json" }} es.input = input req.Handlers.Unmarshal.PushBack(es.sendInitialEvent) {{- end }} {{- end }} {{- if $outputStream }} req.Handlers.Send.Swap(client.LogHTTPResponseHandler.Name, client.LogHTTPResponseHeaderHandler) req.Handlers.Unmarshal.Swap({{ .API.ProtocolPackage }}.UnmarshalHandler.Name, rest.UnmarshalHandler) req.Handlers.Unmarshal.PushBack(es.runOutputStream) {{- if eq .API.Metadata.Protocol "json" }} es.output = output req.Handlers.Unmarshal.PushBack(es.recvInitialEvent) {{- end }} {{- end }} req.Handlers.Unmarshal.PushBack(es.runOnStreamPartClose) {{- end }} {{- end }} {{- if .EndpointDiscovery }} // if custom endpoint for the request is set to a non empty string, // we skip the endpoint discovery workflow. if req.Config.Endpoint == nil \|\| req.Config.Endpoint == "" { {{- if not .EndpointDiscovery.Required }} if aws.BoolValue(req.Config.EnableEndpointDiscovery) { {{- end }} de := discoverer{{ .API.EndpointDiscoveryOp.Name }}{ Required: {{ .EndpointDiscovery.Required }}, EndpointCache: c.endpointCache, Params: map[string]string{ "op": aws.String(req.Operation.Name), {{- range $key, $ref := .InputRef.Shape.MemberRefs -}} {{- if $ref.EndpointDiscoveryID -}} {{- if ne (len $ref.LocationName) 0 -}} "{{ $ref.LocationName }}": input.{{ $key }}, {{- else }} "{{ $key }}": input.{{ $key }}, {{- end }} {{- end }} {{- end }} }, Client: c, } for k, v := range de.Params { if v == nil { delete(de.Params, k) } } req.Handlers.Build.PushFrontNamed(request.NamedHandler{ Name: "crr.endpointdiscovery", Fn: de.Handler, }) {{- if not .EndpointDiscovery.Required }} } {{- end }} } {{- end }} {{- range $_, $handler := $.CustomBuildHandlers }} req.Handlers.Build.PushBackNamed({{ $handler }}) {{- end }} {{- if .RequestChecksumRequired }} {{- $_ := .API.AddSDKImport "private/checksum" }} req.Handlers.Build.PushBackNamed(request.NamedHandler{ Name: "contentMd5Handler", Fn: checksum.AddBodyContentMD5Handler, }) {{- end }} return } // {{ .ExportedName }} API operation for {{ .API.Metadata.ServiceFullName }}. {{- if .Documentation }} // {{ .Documentation }} {{- end }} // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for {{ .API.Metadata.ServiceFullName }}'s // API operation {{ .ExportedName }} for usage and error information. {{- if .ErrorRefs }} // // Returned Error {{ if $.API.WithGeneratedTypedErrors }}Types{{ else }}Codes{{ end }}: {{- range $_, $err := .ErrorRefs -}} {{- if $.API.WithGeneratedTypedErrors }} // {{ $err.ShapeName }} {{- else }} // * {{ $err.Shape.ErrorCodeName }} "{{ $err.Shape.ErrorName}}" {{- end }} {{- if $err.Docstring }} {{ $err.IndentedDocstring }} {{- end }} // {{- end }} {{- end }} {{ $crosslinkURL := $.API.GetCrosslinkURL $.ExportedName -}} {{ if ne $crosslinkURL "" -}} // See also, {{ $crosslinkURL }} {{ end -}} {{- if .Deprecated }}// // Deprecated: {{ GetDeprecatedMsg .DeprecatedMsg .ExportedName }} {{ end -}} func (c {{ .API.StructName }}) {{ .ExportedName }}(` + `input {{ .InputRef.GoType }}) ({{ .OutputRef.GoType }}, error) { req, out := c.{{ .ExportedName }}Request(input) return out, req.Send() } // {{ .ExportedName }}WithContext is the same as {{ .ExportedName }} with the addition of // the ability to pass a context and additional request options. // // See {{ .ExportedName }} for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. {{ if .Deprecated }}// // Deprecated: {{ GetDeprecatedMsg .DeprecatedMsg (printf "%s%s" .ExportedName "WithContext") }} {{ end -}} func (c {{ .API.StructName }}) {{ .ExportedName }}WithContext(` + `ctx aws.Context, input {{ .InputRef.GoType }}, opts ...request.Option) ` + `({{ .OutputRef.GoType }}, error) { req, out := c.{{ .ExportedName }}Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } {{ if .Paginator }} // {{ .ExportedName }}Pages iterates over the pages of a {{ .ExportedName }} operation, // calling the "fn" function with the response data for each page. To stop // iterating, return false from the fn function. // // See {{ .ExportedName }} method for more information on how to use this operation. // // Note: This operation can generate multiple requests to a service. // // // Example iterating over at most 3 pages of a {{ .ExportedName }} operation. // pageNum := 0 // err := client.{{ .ExportedName }}Pages(params, // func(page {{ .OutputRef.Shape.GoTypeWithPkgName }}, lastPage bool) bool { // pageNum++ // fmt.Println(page) // return pageNum <= 3 // }) // {{ if .Deprecated }}// // Deprecated: {{ GetDeprecatedMsg .DeprecatedMsg (printf "%s%s" .ExportedName "Pages") }} {{ end -}} func (c {{ .API.StructName }}) {{ .ExportedName }}Pages(` + `input {{ .InputRef.GoType }}, fn func({{ .OutputRef.GoType }}, bool) bool) error { return c.{{ .ExportedName }}PagesWithContext(aws.BackgroundContext(), input, fn) } // {{ .ExportedName }}PagesWithContext same as {{ .ExportedName }}Pages except // it takes a Context and allows setting request options on the pages. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. {{ if .Deprecated }}// // Deprecated: {{ GetDeprecatedMsg .DeprecatedMsg (printf "%s%s" .ExportedName "PagesWithContext") }} {{ end -}} func (c {{ .API.StructName }}) {{ .ExportedName }}PagesWithContext(` + `ctx aws.Context, ` + `input {{ .InputRef.GoType }}, ` + `fn func({{ .OutputRef.GoType }}, bool) bool, ` + `opts ...request.Option) error { p := request.Pagination { {{ if EnableStopOnSameToken .API.PackageName -}}EndPageOnSameToken: true, {{ end -}} NewRequest: func() (request.Request, error) { var inCpy {{ .InputRef.GoType }} if input != nil { tmp := input inCpy = &tmp } req, _ := c.{{ .ExportedName }}Request(inCpy) req.SetContext(ctx) req.ApplyOptions(opts...) return req, nil }, } for p.Next() { if !fn(p.Page().({{ .OutputRef.GoType }}), !p.HasNextPage()) { break } } return p.Err() } {{ end }} {{- if .IsEndpointDiscoveryOp }} type discoverer{{ .ExportedName }} struct { Client {{ .API.StructName }} Required bool EndpointCache crr.EndpointCache Params map[string]string Key string req request.Request } func (d discoverer{{ .ExportedName }}) Discover() (crr.Endpoint, error) { input := &{{ .API.EndpointDiscoveryOp.InputRef.ShapeName }}{ {{ if .API.EndpointDiscoveryOp.InputRef.Shape.HasMember "Operation" -}} Operation: d.Params["op"], {{ end -}} {{ if .API.EndpointDiscoveryOp.InputRef.Shape.HasMember "Identifiers" -}} Identifiers: d.Params, {{ end -}} } resp, err := d.Client.{{ .API.EndpointDiscoveryOp.Name }}(input) if err != nil { return crr.Endpoint{}, err } endpoint := crr.Endpoint{ Key: d.Key, } for _, e := range resp.Endpoints { if e.Address == nil { continue } address := e.Address var scheme string if idx := strings.Index(address, "://"); idx != -1 { scheme = address[:idx] } if len(scheme) == 0 { address = fmt.Sprintf("%s://%s", d.req.HTTPRequest.URL.Scheme, address) } cachedInMinutes := aws.Int64Value(e.CachePeriodInMinutes) u, err := url.Parse(address) if err != nil { continue } addr := crr.WeightedAddress{ URL: u, Expired: time.Now().Add(time.Duration(cachedInMinutes) * time.Minute), } endpoint.Add(addr) } d.EndpointCache.Add(endpoint) return endpoint, nil } func (d discoverer{{ .ExportedName }}) Handler(r request.Request) { endpointKey := crr.BuildEndpointKey(d.Params) d.Key = endpointKey d.req = r endpoint, err := d.EndpointCache.Get(d, endpointKey, d.Required) if err != nil { r.Error = err return } if endpoint.URL != nil && len(endpoint.URL.String()) > 0 { r.HTTPRequest.URL = endpoint.URL } } {{- end }} `)) // GoCode returns a string of rendered GoCode for this Operation func (o Operation) GoCode() string { var buf bytes.Buffer if o.API.EndpointDiscoveryOp != nil { o.API.AddSDKImport("aws/crr") o.API.AddImport("time") o.API.AddImport("net/url") o.API.AddImport("fmt") o.API.AddImport("strings") } if o.Endpoint != nil && len(o.Endpoint.HostPrefix) != 0 { setupEndpointHostPrefix(o) } if err := operationTmpl.Execute(&buf, o); err != nil { panic(fmt.Sprintf("failed to render operation, %v, %v", o.ExportedName, err)) } if o.EventStreamAPI != nil { o.API.AddSDKImport("aws/client") o.API.AddSDKImport("private/protocol") o.API.AddSDKImport("private/protocol/rest") o.API.AddSDKImport("private/protocol", o.API.ProtocolPackage()) if err := renderEventStreamAPI(&buf, o); err != nil { panic(fmt.Sprintf("failed to render EventStreamAPI for %v, %v", o.ExportedName, err)) } } return strings.TrimSpace(buf.String()) } // tplInfSig defines the template for rendering an Operation's signature within an Interface definition. var tplInfSig = template.Must(template.New("opsig").Parse(` {{ .ExportedName }}({{ .InputRef.GoTypeWithPkgName }}) ({{ .OutputRef.GoTypeWithPkgName }}, error) {{ .ExportedName }}WithContext(aws.Context, {{ .InputRef.GoTypeWithPkgName }}, ...request.Option) ({{ .OutputRef.GoTypeWithPkgName }}, error) {{ .ExportedName }}Request({{ .InputRef.GoTypeWithPkgName }}) (request.Request, {{ .OutputRef.GoTypeWithPkgName }}) {{ if .Paginator -}} {{ .ExportedName }}Pages({{ .InputRef.GoTypeWithPkgName }}, func({{ .OutputRef.GoTypeWithPkgName }}, bool) bool) error {{ .ExportedName }}PagesWithContext(aws.Context, {{ .InputRef.GoTypeWithPkgName }}, func({{ .OutputRef.GoTypeWithPkgName }}, bool) bool, ...request.Option) error {{- end }} `)) // InterfaceSignature returns a string representing the Operation's interface{} // functional signature. func (o Operation) InterfaceSignature() string { var buf bytes.Buffer err := tplInfSig.Execute(&buf, o) if err != nil { panic(err) } return strings.TrimSpace(buf.String()) } // tplExample defines the template for rendering an Operation example var tplExample = template.Must(template.New("operationExample").Parse(` func Example{{ .API.StructName }}_{{ .ExportedName }}() { sess := session.Must(session.NewSession()) svc := {{ .API.PackageName }}.New(sess) {{ .ExampleInput }} resp, err := svc.{{ .ExportedName }}(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) } `)) // Example returns a string of the rendered Go code for the Operation func (o Operation) Example() string { var buf bytes.Buffer err := tplExample.Execute(&buf, o) if err != nil { panic(err) } return strings.TrimSpace(buf.String()) } // ExampleInput return a string of the rendered Go code for an example's input parameters func (o Operation) ExampleInput() string { if len(o.InputRef.Shape.MemberRefs) == 0 { if strings.Contains(o.InputRef.GoTypeElem(), ".") { o.imports[SDKImportRoot+"service/"+strings.Split(o.InputRef.GoTypeElem(), ".")[0]] = true return fmt.Sprintf("var params %s", o.InputRef.GoTypeElem()) } return fmt.Sprintf("var params %s.%s", o.API.PackageName(), o.InputRef.GoTypeElem()) } e := example{o, map[string]int{}} return "params := " + e.traverseAny(o.InputRef.Shape, false, false) } // ShouldDiscardResponse returns if the operation should discard the response // returned by the service. func (o Operation) ShouldDiscardResponse() bool { s := o.OutputRef.Shape return s.Placeholder \|\| len(s.MemberRefs) == 0 } // A example provides type example struct { Operation visited map[string]int } // traverseAny returns rendered Go code for the shape. func (e example) traverseAny(s Shape, required, payload bool) string { str := "" e.visited[s.ShapeName]++ switch s.Type { case "structure": str = e.traverseStruct(s, required, payload) case "list": str = e.traverseList(s, required, payload) case "map": str = e.traverseMap(s, required, payload) case "jsonvalue": str = "aws.JSONValue{\"key\": \"value\"}" if required { str += " // Required" } default: str = e.traverseScalar(s, required, payload) } e.visited[s.ShapeName]-- return str } var reType = regexp.MustCompile(`\b([A-Z])`) // traverseStruct returns rendered Go code for a structure type shape. func (e example) traverseStruct(s Shape, required, payload bool) string { var buf bytes.Buffer if s.resolvePkg != "" { e.imports[s.resolvePkg] = true buf.WriteString("&" + s.GoTypeElem() + "{") } else { buf.WriteString("&" + s.API.PackageName() + "." + s.GoTypeElem() + "{") } if required { buf.WriteString(" // Required") } buf.WriteString("\n") req := make([]string, len(s.Required)) copy(req, s.Required) sort.Strings(req) if e.visited[s.ShapeName] < 2 { for _, n := range req { m := s.MemberRefs[n].Shape p := n == s.Payload && (s.MemberRefs[n].Streaming \|\| m.Streaming) buf.WriteString(n + ": " + e.traverseAny(m, true, p) + ",") if m.Type != "list" && m.Type != "structure" && m.Type != "map" { buf.WriteString(" // Required") } buf.WriteString("\n") } for _, n := range s.MemberNames() { if s.IsRequired(n) { continue } m := s.MemberRefs[n].Shape p := n == s.Payload && (s.MemberRefs[n].Streaming \|\| m.Streaming) buf.WriteString(n + ": " + e.traverseAny(m, false, p) + ",\n") } } else { buf.WriteString("// Recursive values...\n") } buf.WriteString("}") return buf.String() } // traverseMap returns rendered Go code for a map type shape. func (e example) traverseMap(s Shape, required, payload bool) string { var buf bytes.Buffer t := "" if s.resolvePkg != "" { e.imports[s.resolvePkg] = true t = s.GoTypeElem() } else { t = reType.ReplaceAllString(s.GoTypeElem(), s.API.PackageName()+".$1") } buf.WriteString(t + "{") if required { buf.WriteString(" // Required") } buf.WriteString("\n") if e.visited[s.ShapeName] < 2 { m := s.ValueRef.Shape buf.WriteString("\"Key\": " + e.traverseAny(m, true, false) + ",") if m.Type != "list" && m.Type != "structure" && m.Type != "map" { buf.WriteString(" // Required") } buf.WriteString("\n// More values...\n") } else { buf.WriteString("// Recursive values...\n") } buf.WriteString("}") return buf.String() } // traverseList returns rendered Go code for a list type shape. func (e example) traverseList(s Shape, required, payload bool) string { var buf bytes.Buffer t := "" if s.resolvePkg != "" { e.imports[s.resolvePkg] = true t = s.GoTypeElem() } else { t = reType.ReplaceAllString(s.GoTypeElem(), s.API.PackageName()+".$1") } buf.WriteString(t + "{") if required { buf.WriteString(" // Required") } buf.WriteString("\n") if e.visited[s.ShapeName] < 2 { m := s.MemberRef.Shape buf.WriteString(e.traverseAny(m, true, false) + ",") if m.Type != "list" && m.Type != "structure" && m.Type != "map" { buf.WriteString(" // Required") } buf.WriteString("\n// More values...\n") } else { buf.WriteString("// Recursive values...\n") } buf.WriteString("}") return buf.String() } // traverseScalar returns an AWS Type string representation initialized to a value. // Will panic if s is an unsupported shape type. func (e example) traverseScalar(s *Shape, required, payload bool) string { str := "" switch s.Type { case "integer", "long": str = `aws.Int64(1)` case "float", "double": str = `aws.Float64(1.0)` case "string", "character": str = `aws.String("` + s.ShapeName + `")` case "blob": if payload { str = `bytes.NewReader([]byte("PAYLOAD"))` } else { str = `[]byte("PAYLOAD")` } case "boolean": str = `aws.Bool(true)` case "timestamp": str = `aws.Time(time.Now())` default: panic("unsupported shape " + s.Type) } return str }	25.5 KB	2025-05-25 12:27
📄 pagination.go //go:build codegen // +build codegen package api import ( "encoding/json" "fmt" "os" ) // Paginator keeps track of pagination configuration for an API operation. type Paginator struct { InputTokens interface{} `json:"input_token"` OutputTokens interface{} `json:"output_token"` LimitKey string `json:"limit_key"` MoreResults string `json:"more_results"` } // InputTokensString returns output tokens formatted as a list func (p Paginator) InputTokensString() string { str := p.InputTokens.([]string) return fmt.Sprintf("%#v", str) } // OutputTokensString returns output tokens formatted as a list func (p Paginator) OutputTokensString() string { str := p.OutputTokens.([]string) return fmt.Sprintf("%#v", str) } // used for unmarshaling from the paginators JSON file type paginationDefinitions struct { API Pagination map[string]Paginator } // AttachPaginators attaches pagination configuration from filename to the API. func (a API) AttachPaginators(filename string) error { p := paginationDefinitions{API: a} f, err := os.Open(filename) defer f.Close() if err != nil { return err } err = json.NewDecoder(f).Decode(&p) if err != nil { return fmt.Errorf("failed to decode %s, err: %v", filename, err) } return p.setup() } // setup runs post-processing on the paginator configuration. func (p *paginationDefinitions) setup() error { for n, e := range p.Pagination { if e.InputTokens == nil \|\| e.OutputTokens == nil { continue } if _, ok := p.Operations[n]; !ok { continue } paginator := e switch t := paginator.InputTokens.(type) { case string: paginator.InputTokens = []string{t} case []interface{}: toks := []string{} for _, e := range t { s := e.(string) toks = append(toks, s) } paginator.InputTokens = toks } switch t := paginator.OutputTokens.(type) { case string: paginator.OutputTokens = []string{t} case []interface{}: toks := []string{} for _, e := range t { s := e.(string) toks = append(toks, s) } paginator.OutputTokens = toks } p.Operations[n].Paginator = &paginator } return nil } func enableStopOnSameToken(service string) bool { switch service { case "cloudwatchlogs": return true default: return false } }	2.22 KB	2025-05-25 12:27
📄 param_filler.go //go:build codegen // +build codegen package api import ( "encoding/json" "fmt" "reflect" "strings" "github.com/aws/aws-sdk-go/private/util" ) // A paramFiller provides string formatting for a shape and its types. type paramFiller struct { prefixPackageName bool } // typeName returns the type name of a shape. func (f paramFiller) typeName(shape Shape) string { if f.prefixPackageName && shape.Type == "structure" { return "" + shape.API.PackageName() + "." + shape.GoTypeElem() } return shape.GoType() } // ParamsStructFromJSON returns a JSON string representation of a structure. func ParamsStructFromJSON(value interface{}, shape Shape, prefixPackageName bool) string { f := paramFiller{prefixPackageName: prefixPackageName} return util.GoFmt(f.paramsStructAny(value, shape)) } // paramsStructAny returns the string representation of any value. func (f paramFiller) paramsStructAny(value interface{}, shape Shape) string { if value == nil { return "" } switch shape.Type { case "structure": if value != nil { vmap := value.(map[string]interface{}) return f.paramsStructStruct(vmap, shape) } case "list": vlist := value.([]interface{}) return f.paramsStructList(vlist, shape) case "map": vmap := value.(map[string]interface{}) return f.paramsStructMap(vmap, shape) case "string", "character": v := reflect.Indirect(reflect.ValueOf(value)) if v.IsValid() { return fmt.Sprintf("aws.String(%#v)", v.Interface()) } case "blob": v := reflect.Indirect(reflect.ValueOf(value)) if v.IsValid() && shape.Streaming { return fmt.Sprintf("bytes.NewReader([]byte(%#v))", v.Interface()) } else if v.IsValid() { return fmt.Sprintf("[]byte(%#v)", v.Interface()) } case "boolean": v := reflect.Indirect(reflect.ValueOf(value)) if v.IsValid() { return fmt.Sprintf("aws.Bool(%#v)", v.Interface()) } case "integer", "long": v := reflect.Indirect(reflect.ValueOf(value)) if v.IsValid() { return fmt.Sprintf("aws.Int64(%v)", v.Interface()) } case "float", "double": v := reflect.Indirect(reflect.ValueOf(value)) if v.IsValid() { return fmt.Sprintf("aws.Float64(%v)", v.Interface()) } case "timestamp": v := reflect.Indirect(reflect.ValueOf(value)) if v.IsValid() { return fmt.Sprintf("aws.Time(time.Unix(%d, 0))", int(v.Float())) } case "jsonvalue": v, err := json.Marshal(value) if err != nil { panic("failed to marshal JSONValue, " + err.Error()) } const tmpl = `func() aws.JSONValue { var m aws.JSONValue if err := json.Unmarshal([]byte(%q), &m); err != nil { panic("failed to unmarshal JSONValue, "+err.Error()) } return m }()` return fmt.Sprintf(tmpl, string(v)) default: panic("Unhandled type " + shape.Type) } return "" } // paramsStructStruct returns the string representation of a structure func (f paramFiller) paramsStructStruct(value map[string]interface{}, shape Shape) string { out := "&" + f.typeName(shape)[1:] + "{\n" for _, n := range shape.MemberNames() { ref := shape.MemberRefs[n] name := findParamMember(value, n) if val := f.paramsStructAny(value[name], ref.Shape); val != "" { out += fmt.Sprintf("%s: %s,\n", n, val) } } out += "}" return out } // paramsStructMap returns the string representation of a map of values func (f paramFiller) paramsStructMap(value map[string]interface{}, shape Shape) string { out := f.typeName(shape) + "{\n" keys := util.SortedKeys(value) for _, k := range keys { v := value[k] out += fmt.Sprintf("%q: %s,\n", k, f.paramsStructAny(v, shape.ValueRef.Shape)) } out += "}" return out } // paramsStructList returns the string representation of slice of values func (f paramFiller) paramsStructList(value []interface{}, shape *Shape) string { out := f.typeName(shape) + "{\n" for _, v := range value { out += fmt.Sprintf("%s,\n", f.paramsStructAny(v, shape.MemberRef.Shape)) } out += "}" return out } // findParamMember searches a map for a key ignoring case. Returns the map key if found. func findParamMember(value map[string]interface{}, key string) string { for actualKey := range value { if strings.EqualFold(key, actualKey) { return actualKey } } return "" }	4.1 KB	2025-05-25 12:27
📄 passes.go //go:build codegen // +build codegen package api import ( "fmt" "regexp" "strings" "unicode" ) func (a API) enableGeneratedTypedErrors() { switch a.Metadata.Protocol { case "json": case "rest-json": default: return } a.WithGeneratedTypedErrors = true } // updateTopLevelShapeReferences moves resultWrapper, locationName, and // xmlNamespace traits from toplevel shape references to the toplevel // shapes for easier code generation func (a API) updateTopLevelShapeReferences() { for _, o := range a.Operations { // these are for REST-XML services if o.InputRef.LocationName != "" { o.InputRef.Shape.LocationName = o.InputRef.LocationName } if o.InputRef.Location != "" { o.InputRef.Shape.Location = o.InputRef.Location } if o.InputRef.Payload != "" { o.InputRef.Shape.Payload = o.InputRef.Payload } if o.InputRef.XMLNamespace.Prefix != "" { o.InputRef.Shape.XMLNamespace.Prefix = o.InputRef.XMLNamespace.Prefix } if o.InputRef.XMLNamespace.URI != "" { o.InputRef.Shape.XMLNamespace.URI = o.InputRef.XMLNamespace.URI } } } // writeShapeNames sets each shape's API and shape name values. Binding the // shape to its parent API. This will set OrigShapeName on each Shape and ShapeRef // to allow access to the original shape name for code generation. func (a API) writeShapeNames() { writeOrigShapeName := func(s ShapeRef) { if len(s.ShapeName) > 0 { s.OrigShapeName = s.ShapeName } } for n, s := range a.Shapes { s.API = a s.ShapeName, s.OrigShapeName = n, n for _, ref := range s.MemberRefs { writeOrigShapeName(ref) } writeOrigShapeName(&s.MemberRef) writeOrigShapeName(&s.KeyRef) writeOrigShapeName(&s.ValueRef) } } func (a API) resolveReferences() { resolver := referenceResolver{API: a, visited: map[ShapeRef]bool{}} for _, s := range a.Shapes { resolver.resolveShape(s) } for _, o := range a.Operations { o.API = a // resolve parent reference resolver.resolveReference(&o.InputRef) resolver.resolveReference(&o.OutputRef) // Resolve references for errors also for i := range o.ErrorRefs { resolver.resolveReference(&o.ErrorRefs[i]) o.ErrorRefs[i].Shape.Exception = true o.ErrorRefs[i].Shape.ErrorInfo.Type = o.ErrorRefs[i].Shape.ShapeName } } } func (a API) backfillErrorMembers() { stubShape := &Shape{ ShapeName: "string", Type: "string", } var locName string switch a.Metadata.Protocol { case "ec2", "query", "rest-xml": locName = "Message" case "json", "rest-json": locName = "message" } for _, s := range a.Shapes { if !s.Exception { continue } var haveMessage bool for name := range s.MemberRefs { if strings.EqualFold(name, "Message") { haveMessage = true break } } if !haveMessage { ref := &ShapeRef{ ShapeName: stubShape.ShapeName, Shape: stubShape, LocationName: locName, } s.MemberRefs["Message"] = ref stubShape.refs = append(stubShape.refs, ref) } } if len(stubShape.refs) != 0 { a.Shapes["SDKStubErrorMessageShape"] = stubShape } } // A referenceResolver provides a way to resolve shape references to // shape definitions. type referenceResolver struct { API visited map[ShapeRef]bool } // resolveReference updates a shape reference to reference the API and // its shape definition. All other nested references are also resolved. func (r referenceResolver) resolveReference(ref ShapeRef) { if ref.ShapeName == "" { return } shape, ok := r.API.Shapes[ref.ShapeName] if !ok { panic(fmt.Sprintf("unable resolve reference, %s", ref.ShapeName)) } if ref.JSONValue { if err := setTargetAsJSONValue(r.API, "", "", ref); err != nil { panic(fmt.Sprintf("failed to set reference as JSONValue, %v", err)) } } ref.API = r.API // resolve reference back to API ref.Shape = shape // resolve shape reference if r.visited[ref] { return } r.visited[ref] = true shape.refs = append(shape.refs, ref) // register the ref // resolve shape's references, if it has any r.resolveShape(shape) } func setTargetAsJSONValue(a API, parentName, refName string, ref ShapeRef) error { ref.ShapeName = "JSONValue" if _, ok := a.Shapes[ref.ShapeName]; !ok { a.Shapes[ref.ShapeName] = &Shape{ API: a, ShapeName: "JSONValue", Type: "jsonvalue", ValueRef: ShapeRef{ JSONValue: true, }, } } return nil } // resolveShape resolves a shape's Member Key Value, and nested member // shape references. func (r referenceResolver) resolveShape(shape Shape) { r.resolveReference(&shape.MemberRef) r.resolveReference(&shape.KeyRef) r.resolveReference(&shape.ValueRef) for _, m := range shape.MemberRefs { r.resolveReference(m) } } // fixStutterNames fixes all name stuttering based on Go naming conventions. // "Stuttering" is when the prefix of a structure or function matches the // package name (case insensitive). func (a API) fixStutterNames() { names, ok := legacyStutterNames[ServiceID(a)] if !ok { return } shapeNames := names.ShapeOrder if len(shapeNames) == 0 { shapeNames = make([]string, 0, len(names.Shapes)) for k := range names.Shapes { shapeNames = append(shapeNames, k) } } for _, shapeName := range shapeNames { s := a.Shapes[shapeName] newName := names.Shapes[shapeName] if other, ok := a.Shapes[newName]; ok && (other.Type == "structure" \|\| other.Type == "enum") { panic(fmt.Sprintf( "shape name already exists, renaming %v to %v\n", s.ShapeName, newName)) } s.Rename(newName) } for opName, newName := range names.Operations { if _, ok := a.Operations[newName]; ok { panic(fmt.Sprintf( "operation name already exists, renaming %v to %v\n", opName, newName)) } op := a.Operations[opName] delete(a.Operations, opName) a.Operations[newName] = op op.ExportedName = newName } } // regexpForValidatingShapeName is used by validateShapeName to filter acceptable shape names // that may be renamed to a new valid shape name, if not already. // The regex allows underscores(_) at the beginning of the shape name // There may be 0 or more underscores(_). The next character would be the leading character // in the renamed shape name and thus, must be an alphabetic character. // The regex allows alphanumeric characters along with underscores(_) in rest of the string. var regexForValidatingShapeName = regexp.MustCompile("^[_][a-zA-Z][a-zA-Z0-9_]$") // legacyShapeNames is a map of shape names that are supported and bypass the validateShapeNames util var legacyShapeNames = map[string][]string{ "mediapackage": { "__AdTriggersElement", "__PeriodTriggersElement", }, } // validateShapeNames is valid only for shapes of type structure or enums // We validate a shape name to check if its a valid shape name // A valid shape name would only contain alphanumeric characters and have an alphabet as leading character. // // If we encounter a shape name with underscores(_), we remove the underscores, and // follow a canonical upper camel case naming scheme to create a new shape name. // If the shape name collides with an existing shape name we return an error. // The resulting shape name must be a valid shape name or throw an error. func (a API) validateShapeNames() error { loop: for _, s := range a.Shapes { if s.Type == "structure" \|\| s.IsEnum() { for _, legacyname := range legacyShapeNames[a.PackageName()] { if s.ShapeName == legacyname { continue loop } } name := s.ShapeName if b := regexForValidatingShapeName.MatchString(name); !b { return fmt.Errorf("invalid shape name found: %v", s.ShapeName) } // Slice of strings returned after we split a string // with a non alphanumeric character as delimiter. slice := strings.FieldsFunc(name, func(r rune) bool { return !unicode.IsLetter(r) && !unicode.IsNumber(r) }) // Build a string that follows canonical upper camel casing var b strings.Builder for _, word := range slice { b.WriteString(strings.Title(word)) } name = b.String() if s.ShapeName != name { if a.Shapes[name] != nil { // throw an error if shape with a new shape name already exists return fmt.Errorf("attempt to rename shape %v to %v for package %v failed, as this rename would result in shape name collision", s.ShapeName, name, a.PackageName()) } debugLogger.Logf("Renaming shape %v to %v for package %v \n", s.ShapeName, name, a.PackageName()) s.Rename(name) } } } return nil } // renameExportable renames all operation names to be exportable names. // All nested Shape names are also updated to the exportable variant. func (a API) renameExportable() { for name, op := range a.Operations { newName := a.ExportableName(name) if newName != name { delete(a.Operations, name) a.Operations[newName] = op } op.ExportedName = newName } for k, s := range a.Shapes { // FIXME SNS has lower and uppercased shape names with the same name, // except the lowercased variant is used exclusively for string and // other primitive types. Renaming both would cause a collision. // We work around this by only renaming the structure shapes. if s.Type == "string" { continue } for mName, member := range s.MemberRefs { newName := a.ExportableName(mName) if newName != mName { delete(s.MemberRefs, mName) s.MemberRefs[newName] = member // also apply locationName trait so we keep the old one // but only if there's no locationName trait on ref or shape if member.LocationName == "" && member.Shape.LocationName == "" { member.LocationName = mName } } member.OriginalMemberName = mName if newName == "_" { panic("Shape " + s.ShapeName + " uses reserved member name '_'") } } newName := a.ExportableName(k) if s.Type == "structure" && newName == a.StructName() { // If struct collides client's struct type name the shape needs to // be renamed with a trailing `_` to prevent collision. newName += "_" } if newName != s.ShapeName { s.Rename(newName) } s.Payload = a.ExportableName(s.Payload) // fix required trait names for i, n := range s.Required { s.Required[i] = a.ExportableName(n) } } for _, s := range a.Shapes { // fix enum names if s.IsEnum() { s.EnumConsts = make([]string, len(s.Enum)) for i := range s.Enum { shape := s.ShapeName shape = strings.ToUpper(shape[0:1]) + shape[1:] s.EnumConsts[i] = shape + s.EnumName(i) } } } } // renameCollidingFields will rename any fields that uses an SDK or Golang // specific name. func (a API) renameCollidingFields() { for _, v := range a.Shapes { namesWithSet := map[string]struct{}{} for k, field := range v.MemberRefs { if _, ok := v.MemberRefs["Set"+k]; ok { namesWithSet["Set"+k] = struct{}{} } if collides(k) \|\| (v.Exception && exceptionCollides(k)) { renameCollidingField(k, v, field) } } // checks if any field names collide with setters. for name := range namesWithSet { field := v.MemberRefs[name] renameCollidingField(name, v, field) } } } func renameCollidingField(name string, v Shape, field ShapeRef) { newName := name + "_" debugLogger.Logf("Shape %s's field %q renamed to %q", v.ShapeName, name, newName) delete(v.MemberRefs, name) v.MemberRefs[newName] = field // Set LocationName to the original field name if it is not already set. // This is to ensure we correctly serialize to the proper member name if len(field.LocationName) == 0 { field.LocationName = name } } // collides will return true if it is a name used by the SDK or Golang. func collides(name string) bool { switch name { case "String", "GoString", "Validate": return true } return false } func exceptionCollides(name string) bool { switch name { case "Code", "Message", "OrigErr", "Error", "String", "GoString", "RequestID", "StatusCode", "RespMetadata": return true } return false } func (a API) applyShapeNameAliases() { service, ok := shapeNameAliases[a.name] if !ok { return } // Generic Shape Aliases for name, s := range a.Shapes { if alias, ok := service[name]; ok { s.Rename(alias) s.AliasedShapeName = true } } } // renameIOSuffixedShapeNames renames shapes that have `Input` or `Output` // as suffix in their shape names. We add `_` and the end to avoid possible // conflicts with the generated operation input/output types. SDK has already // released quite a few shapes with input, output name suffixed with Input or Output. // This change uses a legacy IO suffixed list and does not rename those legacy shapes. // We do not rename aliased shapes. We do not rename shapes that are an input or output // shape of an operation. func (a API) renameIOSuffixedShapeNames() { // map all input shapes in service enclosure inputShapes := make(map[string]Shape, len(a.Operations)) // map all output shapes in service enclosure outputShapes := make(map[string]Shape, len(a.Operations)) for _, op := range a.Operations { if len(op.InputRef.ShapeName) != 0 { inputShapes[op.InputRef.Shape.ShapeName] = op.InputRef.Shape } if len(op.OutputRef.ShapeName) != 0 { outputShapes[op.OutputRef.Shape.ShapeName] = op.OutputRef.Shape } } for name, shape := range a.Shapes { // skip if this shape is already aliased if shape.AliasedShapeName { continue } // skip if shape name is not suffixed with `Input` or `Output` if !strings.HasSuffix(name, "Input") && !strings.HasSuffix(name, "Output") { continue } // skip if this shape is an input shape if s, ok := inputShapes[name]; ok && s == shape { continue } // skip if this shape is an output shape if s, ok := outputShapes[name]; ok && s == shape { continue } // skip if this shape is a legacy io suffixed shape if legacyIOSuffixed.LegacyIOSuffix(a, name) { continue } // rename the shape to suffix with `_` shape.Rename(name + "_") } } // createInputOutputShapes creates toplevel input/output shapes if they // have not been defined in the API. This normalizes all APIs to always // have an input and output structure in the signature. func (a API) createInputOutputShapes() { for _, op := range a.Operations { createAPIParamShape(a, op.Name, &op.InputRef, op.ExportedName+"Input", shamelist.Input, ) op.InputRef.Shape.UsedAsInput = true createAPIParamShape(a, op.Name, &op.OutputRef, op.ExportedName+"Output", shamelist.Output, ) op.OutputRef.Shape.UsedAsOutput = true } } func (a API) renameAPIPayloadShapes() { for _, op := range a.Operations { op.InputRef.Payload = a.ExportableName(op.InputRef.Payload) op.OutputRef.Payload = a.ExportableName(op.OutputRef.Payload) } } func createAPIParamShape(a API, opName string, ref ShapeRef, shapeName string, shamelistLookup func(string, string) bool) { if len(ref.ShapeName) == 0 { setAsPlacholderShape(ref, shapeName, a) return } // nothing to do if already the correct name. if s := ref.Shape; s.AliasedShapeName \|\| s.ShapeName == shapeName \|\| shamelistLookup(a.name, opName) { return } if s, ok := a.Shapes[shapeName]; ok { panic(fmt.Sprintf( "attempting to create duplicate API parameter shape, %v, %v, %v, %v\n", shapeName, opName, ref.ShapeName, s.OrigShapeName, )) } ref.Shape.removeRef(ref) ref.ShapeName = shapeName ref.Shape = ref.Shape.Clone(shapeName) ref.Shape.refs = append(ref.Shape.refs, ref) } func setAsPlacholderShape(tgtShapeRef ShapeRef, name string, a API) { shape := a.makeIOShape(name) shape.Placeholder = true tgtShapeRef = ShapeRef{API: a, ShapeName: shape.ShapeName, Shape: shape} shape.refs = append(shape.refs, tgtShapeRef) } // makeIOShape returns a pointer to a new Shape initialized by the name provided. func (a API) makeIOShape(name string) Shape { shape := &Shape{ API: a, ShapeName: name, Type: "structure", MemberRefs: map[string]ShapeRef{}, } a.Shapes[name] = shape return shape } // removeUnusedShapes removes shapes from the API which are not referenced by // any other shape in the API. func (a API) removeUnusedShapes() { for _, s := range a.Shapes { if len(s.refs) == 0 { a.removeShape(s) } } } // Sets the EndpointsID field of Metadata with the value of the // EndpointPrefix if EndpointsID is not set. func (a API) setMetadataEndpointsKey() { if len(a.Metadata.EndpointsID) != 0 { return } a.Metadata.EndpointsID = a.Metadata.EndpointPrefix } func (a API) findEndpointDiscoveryOp() { for _, op := range a.Operations { if op.IsEndpointDiscoveryOp { a.EndpointDiscoveryOp = op return } } } func (a *API) injectUnboundedOutputStreaming() { for _, op := range a.Operations { if op.AuthType != V4UnsignedBodyAuthType { continue } for _, ref := range op.InputRef.Shape.MemberRefs { if ref.Streaming \|\| ref.Shape.Streaming { if len(ref.Documentation) != 0 { ref.Documentation += ` //` } ref.Documentation += ` // To use an non-seekable io.Reader for this request wrap the io.Reader with // "aws.ReadSeekCloser". The SDK will not retry request errors for non-seekable // readers. This will allow the SDK to send the reader's payload as chunked // transfer encoding.` } } } }	16.84 KB	2025-05-25 12:27
📄 passes_test.go //go:build go1.8 && codegen // +build go1.8,codegen package api import ( "reflect" "strconv" "strings" "testing" ) func TestUniqueInputAndOutputs(t testing.T) { const serviceName = "FooService" shamelist[serviceName] = map[string]persistAPIType{ "OpOutputNoRename": { output: true, }, "OpInputNoRename": { input: true, }, "OpBothNoRename": { input: true, output: true, }, } cases := [][]struct { expectedInput string expectedOutput string operation string input string output string }{ { { expectedInput: "FooOperationInput", expectedOutput: "FooOperationOutput", operation: "FooOperation", input: "FooInputShape", output: "FooOutputShape", }, { expectedInput: "BarOperationInput", expectedOutput: "BarOperationOutput", operation: "BarOperation", input: "FooInputShape", output: "FooOutputShape", }, }, { { expectedInput: "FooOperationInput", expectedOutput: "FooOperationOutput", operation: "FooOperation", input: "FooInputShape", output: "FooOutputShape", }, { expectedInput: "OpOutputNoRenameInput", expectedOutput: "OpOutputNoRenameOutputShape", operation: "OpOutputNoRename", input: "OpOutputNoRenameInputShape", output: "OpOutputNoRenameOutputShape", }, }, { { expectedInput: "FooOperationInput", expectedOutput: "FooOperationOutput", operation: "FooOperation", input: "FooInputShape", output: "FooOutputShape", }, { expectedInput: "OpInputNoRenameInputShape", expectedOutput: "OpInputNoRenameOutput", operation: "OpInputNoRename", input: "OpInputNoRenameInputShape", output: "OpInputNoRenameOutputShape", }, }, { { expectedInput: "FooOperationInput", expectedOutput: "FooOperationOutput", operation: "FooOperation", input: "FooInputShape", output: "FooOutputShape", }, { expectedInput: "OpInputNoRenameInputShape", expectedOutput: "OpInputNoRenameOutputShape", operation: "OpBothNoRename", input: "OpInputNoRenameInputShape", output: "OpInputNoRenameOutputShape", }, }, } for i, c := range cases { t.Run(strconv.Itoa(i), func(t testing.T) { a := &API{ name: serviceName, Operations: map[string]Operation{}, Shapes: map[string]Shape{}, } expected := map[string][]string{} for _, op := range c { o := &Operation{ Name: op.operation, ExportedName: op.operation, InputRef: ShapeRef{ API: a, ShapeName: op.input, Shape: &Shape{ API: a, ShapeName: op.input, }, }, OutputRef: ShapeRef{ API: a, ShapeName: op.output, Shape: &Shape{ API: a, ShapeName: op.output, }, }, } o.InputRef.Shape.refs = append(o.InputRef.Shape.refs, &o.InputRef) o.OutputRef.Shape.refs = append(o.OutputRef.Shape.refs, &o.OutputRef) a.Operations[o.Name] = o a.Shapes[op.input] = o.InputRef.Shape a.Shapes[op.output] = o.OutputRef.Shape expected[op.operation] = append(expected[op.operation], op.expectedInput, op.expectedOutput, ) } a.fixStutterNames() a.applyShapeNameAliases() a.createInputOutputShapes() for k, v := range expected { if e, ac := v[0], a.Operations[k].InputRef.Shape.ShapeName; e != ac { t.Errorf("Error %s case: Expected %q, but received %q", k, e, ac) } if e, ac := v[1], a.Operations[k].OutputRef.Shape.ShapeName; e != ac { t.Errorf("Error %s case: Expected %q, but received %q", k, e, ac) } } }) } } func TestCollidingFields(t testing.T) { cases := map[string]struct { MemberRefs map[string]ShapeRef Expect []string IsException bool }{ "SimpleMembers": { MemberRefs: map[string]ShapeRef{ "Code": {}, "Foo": {}, "GoString": {}, "Message": {}, "OrigErr": {}, "SetFoo": {}, "String": {}, "Validate": {}, }, Expect: []string{ "Code", "Foo", "GoString_", "Message", "OrigErr", "SetFoo_", "String_", "Validate_", }, }, "ExceptionShape": { IsException: true, MemberRefs: map[string]ShapeRef{ "Code": {}, "Message": {}, "OrigErr": {}, "Other": {}, "String": {}, }, Expect: []string{ "Code_", "Message_", "OrigErr_", "Other", "String_", }, }, } for k, c := range cases { t.Run(k, func(t testing.T) { a := &API{ Shapes: map[string]Shape{ "shapename": { ShapeName: k, MemberRefs: c.MemberRefs, Exception: c.IsException, }, }, } a.renameCollidingFields() for i, name := range a.Shapes["shapename"].MemberNames() { if e, a := c.Expect[i], name; e != a { t.Errorf("expect %v, got %v", e, a) } } }) } } func TestCollidingFields_MaintainOriginalName(t testing.T) { cases := map[string]struct { MemberRefs map[string]ShapeRef Expect map[string]ShapeRef }{ "NoLocationName": { MemberRefs: map[string]ShapeRef{ "String": {}, }, Expect: map[string]ShapeRef{ "String_": {LocationName: "String"}, }, }, "ExitingLocationName": { MemberRefs: map[string]ShapeRef{ "String": {LocationName: "OtherName"}, }, Expect: map[string]ShapeRef{ "String_": {LocationName: "OtherName"}, }, }, } for k, c := range cases { t.Run(k, func(t testing.T) { a := &API{ Shapes: map[string]Shape{ "shapename": { ShapeName: k, MemberRefs: c.MemberRefs, }, }, } a.renameCollidingFields() if e, a := c.Expect, a.Shapes["shapename"].MemberRefs; !reflect.DeepEqual(e, a) { t.Errorf("expect %v, got %v", e, a) } }) } } func TestCreateInputOutputShapes(t testing.T) { meta := Metadata{ APIVersion: "0000-00-00", EndpointPrefix: "rpcservice", JSONVersion: "1.1", Protocol: "json", ServiceAbbreviation: "RPCService", ServiceFullName: "RPC Service", ServiceID: "RPCService", SignatureVersion: "v4", TargetPrefix: "RPCService_00000000", UID: "RPCService-0000-00-00", } type OpExpect struct { Input string Output string } cases := map[string]struct { API API ExpectOps map[string]OpExpect ExpectShapes []string }{ "allRename": { API: &API{Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpRequest"}, OutputRef: ShapeRef{ShapeName: "FirstOpResponse"}, }, "SecondOp": { Name: "SecondOp", InputRef: ShapeRef{ShapeName: "SecondOpRequest"}, OutputRef: ShapeRef{ShapeName: "SecondOpResponse"}, }, }, Shapes: map[string]Shape{ "FirstOpRequest": { ShapeName: "FirstOpRequest", Type: "structure", }, "FirstOpResponse": { ShapeName: "FirstOpResponse", Type: "structure", }, "SecondOpRequest": { ShapeName: "SecondOpRequest", Type: "structure", }, "SecondOpResponse": { ShapeName: "SecondOpResponse", Type: "structure", }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, "SecondOp": { Input: "SecondOpInput", Output: "SecondOpOutput", }, }, ExpectShapes: []string{ "FirstOpInput", "FirstOpOutput", "SecondOpInput", "SecondOpOutput", }, }, "noRename": { API: &API{Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpInput"}, OutputRef: ShapeRef{ShapeName: "FirstOpOutput"}, }, "SecondOp": { Name: "SecondOp", InputRef: ShapeRef{ShapeName: "SecondOpInput"}, OutputRef: ShapeRef{ShapeName: "SecondOpOutput"}, }, }, Shapes: map[string]Shape{ "FirstOpInput": { ShapeName: "FirstOpInput", Type: "structure", }, "FirstOpOutput": { ShapeName: "FirstOpOutput", Type: "structure", }, "SecondOpInput": { ShapeName: "SecondOpInput", Type: "structure", }, "SecondOpOutput": { ShapeName: "SecondOpOutput", Type: "structure", }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, "SecondOp": { Input: "SecondOpInput", Output: "SecondOpOutput", }, }, ExpectShapes: []string{ "FirstOpInput", "FirstOpOutput", "SecondOpInput", "SecondOpOutput", }, }, "renameWithNested": { API: &API{Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpWriteMe"}, OutputRef: ShapeRef{ShapeName: "FirstOpReadMe"}, }, "SecondOp": { Name: "SecondOp", InputRef: ShapeRef{ShapeName: "SecondOpWriteMe"}, OutputRef: ShapeRef{ShapeName: "SecondOpReadMe"}, }, }, Shapes: map[string]Shape{ "FirstOpWriteMe": { ShapeName: "FirstOpWriteMe", Type: "structure", MemberRefs: map[string]ShapeRef{ "Foo": {ShapeName: "String"}, }, }, "FirstOpReadMe": { ShapeName: "FirstOpReadMe", Type: "structure", MemberRefs: map[string]ShapeRef{ "Bar": {ShapeName: "Struct"}, "Once": {ShapeName: "Once"}, }, }, "SecondOpWriteMe": { ShapeName: "SecondOpWriteMe", Type: "structure", }, "SecondOpReadMe": { ShapeName: "SecondOpReadMe", Type: "structure", }, "Once": { ShapeName: "Once", Type: "string", }, "String": { ShapeName: "String", Type: "string", }, "Struct": { ShapeName: "Struct", Type: "structure", MemberRefs: map[string]ShapeRef{ "Foo": {ShapeName: "String"}, "Bar": {ShapeName: "Struct"}, }, }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, "SecondOp": { Input: "SecondOpInput", Output: "SecondOpOutput", }, }, ExpectShapes: []string{ "FirstOpInput", "FirstOpOutput", "Once", "SecondOpInput", "SecondOpOutput", "String", "Struct", }, }, "aliasedInput": { API: &API{Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpRequest"}, OutputRef: ShapeRef{ShapeName: "FirstOpResponse"}, }, }, Shapes: map[string]Shape{ "FirstOpRequest": { ShapeName: "FirstOpRequest", Type: "structure", AliasedShapeName: true, }, "FirstOpResponse": { ShapeName: "FirstOpResponse", Type: "structure", }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpRequest", Output: "FirstOpOutput", }, }, ExpectShapes: []string{ "FirstOpOutput", "FirstOpRequest", }, }, "aliasedOutput": { API: &API{ Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpRequest"}, OutputRef: ShapeRef{ShapeName: "FirstOpResponse"}, }, }, Shapes: map[string]Shape{ "FirstOpRequest": { ShapeName: "FirstOpRequest", Type: "structure", }, "FirstOpResponse": { ShapeName: "FirstOpResponse", Type: "structure", AliasedShapeName: true, }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpResponse", }, }, ExpectShapes: []string{ "FirstOpInput", "FirstOpResponse", }, }, "resusedShape": { API: &API{ Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpRequest"}, OutputRef: ShapeRef{ShapeName: "ReusedShape"}, }, }, Shapes: map[string]Shape{ "FirstOpRequest": { ShapeName: "FirstOpRequest", Type: "structure", MemberRefs: map[string]ShapeRef{ "Foo": {ShapeName: "ReusedShape"}, "ooF": {ShapeName: "ReusedShapeList"}, }, }, "ReusedShape": { ShapeName: "ReusedShape", Type: "structure", }, "ReusedShapeList": { ShapeName: "ReusedShapeList", Type: "list", MemberRef: ShapeRef{ShapeName: "ReusedShape"}, }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, }, ExpectShapes: []string{ "FirstOpInput", "FirstOpOutput", "ReusedShape", "ReusedShapeList", }, }, "aliasedResusedShape": { API: &API{ Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpRequest"}, OutputRef: ShapeRef{ShapeName: "ReusedShape"}, }, }, Shapes: map[string]Shape{ "FirstOpRequest": { ShapeName: "FirstOpRequest", Type: "structure", MemberRefs: map[string]ShapeRef{ "Foo": {ShapeName: "ReusedShape"}, "ooF": {ShapeName: "ReusedShapeList"}, }, }, "ReusedShape": { ShapeName: "ReusedShape", Type: "structure", AliasedShapeName: true, }, "ReusedShapeList": { ShapeName: "ReusedShapeList", Type: "list", MemberRef: ShapeRef{ShapeName: "ReusedShape"}, }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "ReusedShape", }, }, ExpectShapes: []string{ "FirstOpInput", "ReusedShape", "ReusedShapeList", }, }, "unsetInput": { API: &API{Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", OutputRef: ShapeRef{ShapeName: "FirstOpResponse"}, }, }, Shapes: map[string]Shape{ "FirstOpResponse": { ShapeName: "FirstOpResponse", Type: "structure", }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, }, ExpectShapes: []string{ "FirstOpInput", "FirstOpOutput", }, }, "unsetOutput": { API: &API{Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpRequest"}, }, }, Shapes: map[string]Shape{ "FirstOpRequest": { ShapeName: "FirstOpRequest", Type: "structure", }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, }, ExpectShapes: []string{ "FirstOpInput", "FirstOpOutput", }, }, "collidingShape": { API: &API{ name: "APIClientName", Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpRequest"}, }, }, Shapes: map[string]Shape{ "FirstOpRequest": { ShapeName: "FirstOpRequest", Type: "structure", MemberRefs: map[string]ShapeRef{ "Foo": {ShapeName: "APIClientName"}, "ooF": {ShapeName: "APIClientNameList"}, }, }, "APIClientName": { ShapeName: "APIClientName", Type: "structure", }, "APIClientNameList": { ShapeName: "APIClientNameList", Type: "list", MemberRef: ShapeRef{ShapeName: "APIClientName"}, }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, }, ExpectShapes: []string{ "APIClientNameList", "APIClientName_", "FirstOpInput", "FirstOpOutput", }, }, "MemberShapesWithInputAsSuffix": { API: &API{ name: "APIClientName", Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", InputRef: ShapeRef{ShapeName: "FirstOpRequest"}, }, }, Shapes: map[string]Shape{ "FirstOpRequest": { ShapeName: "FirstOpRequest", Type: "structure", MemberRefs: map[string]ShapeRef{ "Foo": {ShapeName: "APIClientName"}, "ooF": {ShapeName: "FirstOpInput"}, }, }, "APIClientName": { ShapeName: "APIClientName", Type: "structure", }, "FirstOpInput": { ShapeName: "FirstOpInput", Type: "list", MemberRef: ShapeRef{ ShapeName: "APIClientName", }, }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, }, ExpectShapes: []string{ "APIClientName_", "FirstOpInput", "FirstOpInput_", "FirstOpOutput", }, }, "MemberShapesWithOutputAsSuffix": { API: &API{ name: "APIClientName", Metadata: meta, Operations: map[string]Operation{ "FirstOp": { Name: "FirstOp", OutputRef: ShapeRef{ShapeName: "FirstOpResponse"}, }, }, Shapes: map[string]Shape{ "FirstOpResponse": { ShapeName: "FirstOpResponse", Type: "structure", MemberRefs: map[string]ShapeRef{ "Foo": {ShapeName: "APIClientName"}, "ooF": {ShapeName: "FirstOpOutput"}, }, }, "APIClientName": { ShapeName: "APIClientName", Type: "structure", }, "FirstOpOutput": { ShapeName: "FirstOpOutput", Type: "list", MemberRef: ShapeRef{ShapeName: "APIClientName"}, }, }, }, ExpectOps: map[string]OpExpect{ "FirstOp": { Input: "FirstOpInput", Output: "FirstOpOutput", }, }, ExpectShapes: []string{ "APIClientName_", "FirstOpInput", "FirstOpOutput", "FirstOpOutput_", }, }, } for name, c := range cases { t.Run(name, func(t testing.T) { a := c.API a.Setup() for opName, op := range a.Operations { if e, a := op.InputRef.ShapeName, op.InputRef.Shape.ShapeName; e != a { t.Errorf("expect input ref and shape names to match, %s, %s", e, a) } if e, a := c.ExpectOps[opName].Input, op.InputRef.ShapeName; e != a { t.Errorf("expect %v input shape, got %v", e, a) } if e, a := op.OutputRef.ShapeName, op.OutputRef.Shape.ShapeName; e != a { t.Errorf("expect output ref and shape names to match, %s, %s", e, a) } if e, a := c.ExpectOps[opName].Output, op.OutputRef.ShapeName; e != a { t.Errorf("expect %v output shape, got %v", e, a) } } if e, a := c.ExpectShapes, a.ShapeNames(); !reflect.DeepEqual(e, a) { t.Errorf("expect %v shapes, got %v", e, a) } }) } } func TestValidateShapeNameMethod(t testing.T) { cases := map[string]struct { inputShapeName string shapeType string expectedShapeName string expectedError string }{ "empty case": { inputShapeName: "", shapeType: "structure", expectedShapeName: "", expectedError: "invalid shape name found", }, "No rename": { inputShapeName: "Sample123Shape", shapeType: "structure", expectedShapeName: "Sample123Shape", }, "starts with underscores": { inputShapeName: "__Sample123Shape", shapeType: "structure", expectedShapeName: "Sample123Shape", }, "Contains underscores": { inputShapeName: "__sample_123_shape__", shapeType: "structure", expectedShapeName: "Sample123Shape", }, "Starts with numeric character": { inputShapeName: "123__sampleShape", shapeType: "structure", expectedShapeName: "", expectedError: "invalid shape name found", }, "Starts with non alphabetic or non underscore character": { inputShapeName: "&&SampleShape", shapeType: "structure", expectedShapeName: "", expectedError: "invalid shape name found", }, "Contains non Alphanumeric or non underscore character": { inputShapeName: "Sample&__Shape", shapeType: "structure", expectedShapeName: "", expectedError: "invalid shape name found", }, "Renamed Shape already exists": { inputShapeName: "__sample_shape", shapeType: "structure", expectedShapeName: "", expectedError: "rename would result in shape name collision", }, "empty case for enums shape type": { inputShapeName: "", shapeType: "string", expectedShapeName: "", expectedError: "invalid shape name found", }, "No rename for enums shape type": { inputShapeName: "Sample123Shape", shapeType: "string", expectedShapeName: "Sample123Shape", }, "starts with underscores for enums shape type": { inputShapeName: "__Sample123Shape", shapeType: "string", expectedShapeName: "Sample123Shape", }, "Contains underscores for enums shape type": { inputShapeName: "__sample_123_shape__", shapeType: "string", expectedShapeName: "Sample123Shape", }, "Starts with numeric character for enums shape type": { inputShapeName: "123__sampleShape", shapeType: "string", expectedShapeName: "", expectedError: "invalid shape name found", }, "Starts with non alphabetic or non underscore character for enums shape type": { inputShapeName: "&&SampleShape", shapeType: "string", expectedShapeName: "", expectedError: "invalid shape name found", }, "Contains non Alphanumeric or non underscore character for enums shape type": { inputShapeName: "Sample&__Shape", shapeType: "string", expectedShapeName: "", expectedError: "invalid shape name found", }, "Renamed Shape already exists for enums shape type": { inputShapeName: "__sample_shape", shapeType: "string", expectedShapeName: "", expectedError: "rename would result in shape name collision", }, } for name, c := range cases { operation := "FooOperation" t.Run(name, func(t testing.T) { a := &API{ Operations: map[string]Operation{}, Shapes: map[string]Shape{}, } // add another shape with name SampleShape to check for collision a.Shapes["SampleShape"] = &Shape{ShapeName: "SampleShape"} o := &Operation{ Name: operation, ExportedName: operation, InputRef: ShapeRef{ API: a, ShapeName: c.inputShapeName, Shape: &Shape{ API: a, ShapeName: c.inputShapeName, Type: c.shapeType, Enum: []string{"x"}, }, }, } o.InputRef.Shape.refs = append(o.InputRef.Shape.refs, &o.InputRef) a.Operations[o.Name] = o a.Shapes[c.inputShapeName] = o.InputRef.Shape err := a.validateShapeNames() if err != nil \|\| c.expectedError != "" { if err == nil { t.Fatalf("Received no error, expected error with log: \n \t %v ", c.expectedError) } if c.expectedError == "" { t.Fatalf("Expected no error, got %v", err.Error()) } if e, a := err.Error(), c.expectedError; !strings.Contains(e, a) { t.Fatalf("Expected to receive error containing %v, got %v", e, a) } return } if e, a := c.expectedShapeName, o.InputRef.Shape.ShapeName; e != a { t.Fatalf("Expected shape name to be %v, got %v", e, a) } }) } }	23.45 KB	2025-05-25 12:27
📄 s3manger_input.go //go:build codegen // +build codegen package api import ( "bytes" "fmt" "text/template" ) // S3ManagerUploadInputGoCode returns the Go code for the S3 Upload Manager's // input structure. func S3ManagerUploadInputGoCode(a API) string { if v := a.PackageName(); v != "s3" { panic(fmt.Sprintf("unexpected API model %s", v)) } s, ok := a.Shapes["PutObjectInput"] if !ok { panic(fmt.Sprintf("unable to find PutObjectInput shape in S3 model")) } a.resetImports() a.AddImport("io") a.AddImport("time") var w bytes.Buffer if err := s3managerUploadInputTmpl.Execute(&w, s); err != nil { panic(fmt.Sprintf("failed to execute %s template, %v", s3managerUploadInputTmpl.Name(), err)) } return a.importsGoCode() + w.String() } var s3managerUploadInputTmpl = template.Must( template.New("s3managerUploadInputTmpl"). Funcs(template.FuncMap{ "GetDeprecatedMsg": getDeprecatedMessage, "GetDocstring": func(parent Shape, memberName string, ref ShapeRef) string { doc := ref.Docstring() if ref.Deprecated { doc = AppendDocstring(doc, fmt.Sprintf(` Deprecated: %s `, getDeprecatedMessage(ref.DeprecatedMsg, memberName))) } if parent.WillRefBeBase64Encoded(memberName) { doc = AppendDocstring(doc, fmt.Sprintf(` %s is automatically base64 encoded/decoded by the SDK. `, memberName)) } if parent.IsRequired(memberName) { doc = AppendDocstring(doc, fmt.Sprintf(` %s is a required field `, memberName)) } if memberName == "ContentMD5" { doc = AppendDocstring(doc, fmt.Sprintf(` If the ContentMD5 is provided for a multipart upload, it will be ignored. Objects that will be uploaded in a single part, the ContentMD5 will be used. `)) } return doc }, }). Parse(s3managerUploadInputTmplDef), ) const s3managerUploadInputTmplDef = ` // UploadInput provides the input parameters for uploading a stream or buffer // to an object in an Amazon S3 bucket. This type is similar to the s3 // package's PutObjectInput with the exception that the Body member is an // io.Reader instead of an io.ReadSeeker. // // The ContentMD5 member for pre-computed MD5 checksums will be ignored for // multipart uploads. Objects that will be uploaded in a single part, the // ContentMD5 will be used. // // The Checksum members for pre-computed checksums will be ignored for // multipart uploads. Objects that will be uploaded in a single part, will // include the checksum member in the request. type UploadInput struct { _ struct{} {{ .GoTags true false }} {{ range $name, $ref := $.MemberRefs -}} {{ if eq $name "Body" }} // The readable body payload to send to S3. Body io.Reader {{ else if eq $name "ContentLength" }} {{/ S3 Upload Manager does not use modeled content length */}} {{ else }} {{ $isRequired := $.IsRequired $name -}} {{ $doc := GetDocstring $ $name $ref -}} {{ if $doc -}} {{ $doc }} {{- end }} {{ $name }} {{ $.GoStructType $name $ref }} {{ $ref.GoTags false $isRequired }} {{ end }} {{ end }} } `	3 KB	2025-05-25 12:27
📄 service_name.go //go:build codegen // +build codegen package api // ServiceName returns the SDK's naming of the service. Has // backwards compatibility built in for services that were // incorrectly named with the service's endpoint prefix. func ServiceName(a *API) string { if oldName, ok := oldServiceNames[a.PackageName()]; ok { return oldName } return ServiceID(a) } var oldServiceNames = map[string]string{ "migrationhub": "mgh", "acmpca": "acm-pca", "acm": "acm", "alexaforbusiness": "a4b", "apigateway": "apigateway", "applicationautoscaling": "autoscaling", "appstream": "appstream2", "appsync": "appsync", "athena": "athena", "autoscalingplans": "autoscaling", "autoscaling": "autoscaling", "batch": "batch", "budgets": "budgets", "costexplorer": "ce", "cloud9": "cloud9", "clouddirectory": "clouddirectory", "cloudformation": "cloudformation", "cloudfront": "cloudfront", "cloudhsm": "cloudhsm", "cloudhsmv2": "cloudhsmv2", "cloudsearch": "cloudsearch", "cloudsearchdomain": "cloudsearchdomain", "cloudtrail": "cloudtrail", "codebuild": "codebuild", "codecommit": "codecommit", "codedeploy": "codedeploy", "codepipeline": "codepipeline", "codestar": "codestar", "cognitoidentity": "cognito-identity", "cognitoidentityprovider": "cognito-idp", "cognitosync": "cognito-sync", "comprehend": "comprehend", "configservice": "config", "connect": "connect", "costandusagereportservice": "cur", "datapipeline": "datapipeline", "dax": "dax", "devicefarm": "devicefarm", "directconnect": "directconnect", "applicationdiscoveryservice": "discovery", "databasemigrationservice": "dms", "directoryservice": "ds", "dynamodb": "dynamodb", "ec2": "ec2", "ecr": "ecr", "ecs": "ecs", "eks": "eks", "elasticache": "elasticache", "elasticbeanstalk": "elasticbeanstalk", "efs": "elasticfilesystem", "elb": "elasticloadbalancing", "elbv2": "elasticloadbalancing", "emr": "elasticmapreduce", "elastictranscoder": "elastictranscoder", "ses": "email", "marketplaceentitlementservice": "entitlement.marketplace", "elasticsearchservice": "es", "cloudwatchevents": "events", "firehose": "firehose", "fms": "fms", "gamelift": "gamelift", "glacier": "glacier", "glue": "glue", "greengrass": "greengrass", "guardduty": "guardduty", "health": "health", "iam": "iam", "inspector": "inspector", "iotdataplane": "data.iot", "iotjobsdataplane": "data.jobs.iot", "iot": "iot", "iot1clickdevicesservice": "devices.iot1click", "iot1clickprojects": "projects.iot1click", "iotanalytics": "iotanalytics", "kinesisvideoarchivedmedia": "kinesisvideo", "kinesisvideomedia": "kinesisvideo", "kinesis": "kinesis", "kinesisanalytics": "kinesisanalytics", "kinesisvideo": "kinesisvideo", "kms": "kms", "lambda": "lambda", "lexmodelbuildingservice": "models.lex", "lightsail": "lightsail", "cloudwatchlogs": "logs", "machinelearning": "machinelearning", "marketplacecommerceanalytics": "marketplacecommerceanalytics", "mediaconvert": "mediaconvert", "medialive": "medialive", "mediapackage": "mediapackage", "mediastoredata": "data.mediastore", "mediastore": "mediastore", "mediatailor": "api.mediatailor", "marketplacemetering": "metering.marketplace", "mobile": "mobile", "mobileanalytics": "mobileanalytics", "cloudwatch": "monitoring", "mq": "mq", "mturk": "mturk-requester", "neptune": "rds", "opsworks": "opsworks", "opsworkscm": "opsworks-cm", "organizations": "organizations", "pi": "pi", "pinpoint": "pinpoint", "polly": "polly", "pricing": "api.pricing", "rds": "rds", "redshift": "redshift", "rekognition": "rekognition", "resourcegroups": "resource-groups", "resourcegroupstaggingapi": "tagging", "route53": "route53", "route53domains": "route53domains", "lexruntimeservice": "runtime.lex", "sagemakerruntime": "runtime.sagemaker", "s3": "s3", "sagemaker": "sagemaker", "simpledb": "sdb", "secretsmanager": "secretsmanager", "serverlessapplicationrepository": "serverlessrepo", "servicecatalog": "servicecatalog", "servicediscovery": "servicediscovery", "shield": "shield", "sms": "sms", "snowball": "snowball", "sns": "sns", "sqs": "sqs", "ssm": "ssm", "sfn": "states", "storagegateway": "storagegateway", "dynamodbstreams": "streams.dynamodb", "sts": "sts", "support": "support", "swf": "swf", "transcribeservice": "transcribe", "translate": "translate", "wafregional": "waf-regional", "waf": "waf", "workdocs": "workdocs", "workmail": "workmail", "workspaces": "workspaces", "xray": "xray", }	7.23 KB	2025-05-25 12:27
📄 shape.go //go:build codegen // +build codegen package api import ( "bytes" "fmt" "path" "regexp" "sort" "strings" "text/template" "github.com/aws/aws-sdk-go/private/protocol" ) // ErrorInfo represents the error block of a shape's structure type ErrorInfo struct { Type string Code string HTTPStatusCode int } // A XMLInfo defines URL and prefix for Shapes when rendered as XML type XMLInfo struct { Prefix string URI string } // A ShapeRef defines the usage of a shape within the API. type ShapeRef struct { API API `json:"-"` Shape Shape `json:"-"` Documentation string `json:"-"` ShapeName string `json:"shape"` Location string LocationName string QueryName string Flattened bool Streaming bool XMLAttribute bool // References of struct members will include their originally modeled // member name for cross references. OriginalMemberName string `json:"-"` // Ignore, if set, will not be sent over the wire Ignore bool XMLNamespace XMLInfo Payload string IdempotencyToken bool `json:"idempotencyToken"` TimestampFormat string `json:"timestampFormat"` JSONValue bool `json:"jsonvalue"` Deprecated bool `json:"deprecated"` DeprecatedMsg string `json:"deprecatedMessage"` EndpointDiscoveryID bool `json:"endpointdiscoveryid"` HostLabel bool `json:"hostLabel"` OrigShapeName string `json:"-"` GenerateGetter bool IsEventPayload bool `json:"eventpayload"` IsEventHeader bool `json:"eventheader"` // Collection of custom tags the shape reference includes. CustomTags ShapeTags // Flags whether the member reference is a endpoint ARN EndpointARN bool // Flags whether the member reference is a Outpost ID OutpostIDMember bool // Flag whether the member reference is a Account ID when endpoint shape ARN is present AccountIDMemberWithARN bool // Flags that the member was modeled as JSONValue but suppressed by the SDK. SuppressedJSONValue bool `json:"-"` } // A Shape defines the definition of a shape type type Shape struct { API API `json:"-"` ShapeName string Documentation string `json:"-"` // References of struct members will include their originally modeled // member name for cross references. OriginalShapeName string `json:"-"` // Map of exported member names to the ShapeReference. MemberRefs map[string]ShapeRef `json:"members"` MemberRef ShapeRef `json:"member"` // List ref KeyRef ShapeRef `json:"key"` // map key ref ValueRef ShapeRef `json:"value"` // map value ref Required []string Payload string Type string Exception bool Enum []string EnumConsts []string Flattened bool Streaming bool Location string LocationName string IdempotencyToken bool `json:"idempotencyToken"` TimestampFormat string `json:"timestampFormat"` XMLNamespace XMLInfo Min float64 // optional Minimum length (string, list) or value (number) OutputEventStreamAPI EventStreamAPI EventStream EventStream EventFor map[string]EventStream `json:"-"` IsInputEventStream bool `json:"-"` IsOutputEventStream bool `json:"-"` IsEventStream bool `json:"eventstream"` IsEvent bool `json:"event"` refs []ShapeRef // References to this shape resolvePkg string // use this package in the goType() if present OrigShapeName string `json:"-"` // Defines if the shape is a placeholder and should not be used directly Placeholder bool Deprecated bool `json:"deprecated"` DeprecatedMsg string `json:"deprecatedMessage"` Validations ShapeValidations // Error information that is set if the shape is an error shape. ErrorInfo ErrorInfo `json:"error"` // Flags that the shape cannot be rename. Prevents the shape from being // renamed further by the Input/Output. AliasedShapeName bool // Sensitive types should not be logged by SDK type loggers. Sensitive bool `json:"sensitive"` // Flags that a member of the shape is an EndpointARN HasEndpointARNMember bool // Flags that a member of the shape is an OutpostIDMember HasOutpostIDMember bool // Flags that the shape has an account id member along with EndpointARN member HasAccountIdMemberWithARN bool // Indicates the Shape is used as an operation input UsedAsInput bool // Indicates the Shape is used as an operation output UsedAsOutput bool // Indicates a structure shape is a document type Document bool `json:"document"` } // CanBeEmpty returns if the shape value can sent request as an empty value. // String, blob, list, and map are types must not be empty when the member is // serialized to the URI path, or decorated with HostLabel. func (ref ShapeRef) CanBeEmpty() bool { switch ref.Shape.Type { case "string": return !(ref.Location == "uri" \|\| ref.HostLabel) case "blob", "map", "list": return !(ref.Location == "uri") default: return true } } // ErrorCodeName will return the error shape's name formated for // error code const. func (s Shape) ErrorCodeName() string { return "ErrCode" + s.ShapeName } // ErrorName will return the shape's name or error code if available based // on the API's protocol. This is the error code string returned by the service. func (s Shape) ErrorName() string { name := s.ErrorInfo.Type switch s.API.Metadata.Protocol { case "query", "ec2query", "rest-xml": if len(s.ErrorInfo.Code) > 0 { name = s.ErrorInfo.Code } } if len(name) == 0 { name = s.OrigShapeName } if len(name) == 0 { name = s.ShapeName } return name } // PayloadRefName returns the payload member of the shape if there is one // modeled. If no payload is modeled, empty string will be returned. func (s Shape) PayloadRefName() string { if name := s.Payload; len(name) != 0 { // Root shape return name } for name, ref := range s.MemberRefs { if ref.IsEventPayload { return name } } return "" } // GoTags returns the struct tags for a shape. func (s Shape) GoTags(root, required bool) string { ref := &ShapeRef{ShapeName: s.ShapeName, API: s.API, Shape: s} return ref.GoTags(root, required) } // Rename changes the name of the Shape to newName. Also updates // the associated API's reference to use newName. func (s Shape) Rename(newName string) { if s.AliasedShapeName { panic(fmt.Sprintf("attempted to rename %s, but flagged as aliased", s.ShapeName)) } for _, r := range s.refs { r.ShapeName = newName } if s.OriginalShapeName == "" { s.OriginalShapeName = s.ShapeName } delete(s.API.Shapes, s.ShapeName) s.API.Shapes[newName] = s s.ShapeName = newName } // MemberNames returns a slice of struct member names. func (s Shape) MemberNames() []string { i, names := 0, make([]string, len(s.MemberRefs)) for n := range s.MemberRefs { names[i] = n i++ } sort.Strings(names) return names } // HasMember will return whether or not the shape has a given member by name. // Name passed in must match the SDK's exported name for the member, not the // modeled member name func (s Shape) HasMember(name string) bool { _, ok := s.MemberRefs[name] return ok } // GetModeledMember returns the member's ShapeReference if it exists within the // shape. Returns nil if the member could not be found. func (s Shape) GetModeledMember(name string) ShapeRef { for _, ref := range s.MemberRefs { if ref.OriginalMemberName == name { return ref } } return nil } // GoTypeWithPkgName returns a shape's type as a string with the package name in // <packageName>.<type> format. Package naming only applies to structures. func (s Shape) GoTypeWithPkgName() string { return goType(s, true) } // GoTypeWithPkgNameElem returns the shapes type as a string with the "" // removed if there was one preset. func (s Shape) GoTypeWithPkgNameElem() string { t := goType(s, true) if strings.HasPrefix(t, "") { return t[1:] } return t } // UseIndirection returns if the shape's reference should use indirection or not. func (s ShapeRef) UseIndirection() bool { switch s.Shape.Type { case "map", "list", "blob", "structure", "jsonvalue": return false } if s.Streaming \|\| s.Shape.Streaming { return false } if s.JSONValue { return false } return true } func (s Shape) GetTimestampFormat() string { format := s.TimestampFormat if len(format) > 0 && !protocol.IsKnownTimestampFormat(format) { panic(fmt.Sprintf("Unknown timestampFormat %s, for %s", format, s.ShapeName)) } return format } func (ref ShapeRef) GetTimestampFormat() string { format := ref.TimestampFormat if len(format) == 0 { format = ref.Shape.TimestampFormat } if len(format) > 0 && !protocol.IsKnownTimestampFormat(format) { panic(fmt.Sprintf("Unknown timestampFormat %s, for %s", format, ref.ShapeName)) } return format } // GoStructValueType returns the Shape's Go type value instead of a pointer // for the type. func (s Shape) GoStructValueType(name string, ref ShapeRef) string { v := s.GoStructType(name, ref) if ref.UseIndirection() && v[0] == '' { return v[1:] } return v } // GoStructType returns the type of a struct field based on the API // model definition. func (s Shape) GoStructType(name string, ref ShapeRef) string { if (ref.Streaming \|\| ref.Shape.Streaming) && s.Payload == name { rtype := "io.ReadSeeker" if strings.HasSuffix(s.ShapeName, "Output") { rtype = "io.ReadCloser" } s.API.imports["io"] = true return rtype } if ref.JSONValue { s.API.AddSDKImport("aws") return "aws.JSONValue" } for _, v := range s.Validations { // TODO move this to shape validation resolution if (v.Ref.Shape.Type == "map" \|\| v.Ref.Shape.Type == "list") && v.Type == ShapeValidationNested { s.API.imports["fmt"] = true } } return ref.GoType() } // GoType returns a shape's Go type func (s Shape) GoType() string { return goType(s, false) } // GoType returns a shape ref's Go type. func (ref ShapeRef) GoType() string { if ref.Shape == nil { panic(fmt.Errorf("missing shape definition on reference for %#v", ref)) } return ref.Shape.GoType() } // GoTypeWithPkgName returns a shape's type as a string with the package name in // <packageName>.<type> format. Package naming only applies to structures. func (ref ShapeRef) GoTypeWithPkgName() string { if ref.Shape == nil { panic(fmt.Errorf("missing shape definition on reference for %#v", ref)) } return ref.Shape.GoTypeWithPkgName() } // Returns a string version of the Shape's type. // If withPkgName is true, the package name will be added as a prefix func goType(s Shape, withPkgName bool) string { switch s.Type { case "structure": if withPkgName \|\| s.resolvePkg != "" { pkg := s.resolvePkg if pkg != "" { s.API.imports[pkg] = true pkg = path.Base(pkg) } else { pkg = s.API.PackageName() } return fmt.Sprintf("%s.%s", pkg, s.ShapeName) } return "" + s.ShapeName case "map": return "map[string]" + goType(s.ValueRef.Shape, withPkgName) case "jsonvalue": return "aws.JSONValue" case "list": return "[]" + goType(s.MemberRef.Shape, withPkgName) case "boolean": return "bool" case "string", "character": return "string" case "blob": return "[]byte" case "byte", "short", "integer", "long": return "int64" case "float", "double": return "float64" case "timestamp": s.API.imports["time"] = true return "time.Time" default: panic("Unsupported shape type: " + s.Type) } } // GoTypeElem returns the Go type for the Shape. If the shape type is a pointer just // the type will be returned minus the pointer . func (s Shape) GoTypeElem() string { t := s.GoType() if strings.HasPrefix(t, "") { return t[1:] } return t } // GoTypeElem returns the Go type for the Shape. If the shape type is a pointer just // the type will be returned minus the pointer . func (ref ShapeRef) GoTypeElem() string { if ref.Shape == nil { panic(fmt.Errorf("missing shape definition on reference for %#v", ref)) } return ref.Shape.GoTypeElem() } // ShapeTag is a struct tag that will be applied to a shape's generated code type ShapeTag struct { Key, Val string } // String returns the string representation of the shape tag func (s ShapeTag) String() string { return fmt.Sprintf(`%s:"%s"`, s.Key, s.Val) } // ShapeTags is a collection of shape tags and provides serialization of the // tags in an ordered list. type ShapeTags []ShapeTag // Join returns an ordered serialization of the shape tags with the provided // separator. func (s ShapeTags) Join(sep string) string { o := &bytes.Buffer{} for i, t := range s { o.WriteString(t.String()) if i < len(s)-1 { o.WriteString(sep) } } return o.String() } // String is an alias for Join with the empty space separator. func (s ShapeTags) String() string { return s.Join(" ") } // GoTags returns the rendered tags string for the ShapeRef func (ref ShapeRef) GoTags(toplevel bool, isRequired bool) string { tags := append(ShapeTags{}, ref.CustomTags...) var location string if ref.Location != "" { tags = append(tags, ShapeTag{"location", ref.Location}) location = ref.Location } else if ref.Shape.Location != "" { tags = append(tags, ShapeTag{"location", ref.Shape.Location}) location = ref.Shape.Location } else if ref.IsEventHeader { tags = append(tags, ShapeTag{"location", "header"}) location = "header" } if ref.LocationName != "" { tags = append(tags, ShapeTag{"locationName", ref.LocationName}) } else if ref.Shape.LocationName != "" { tags = append(tags, ShapeTag{"locationName", ref.Shape.LocationName}) } else if len(ref.Shape.EventFor) != 0 && ref.API.Metadata.Protocol == "rest-xml" { // RPC JSON events need to have location name modeled for round trip testing. tags = append(tags, ShapeTag{"locationName", ref.Shape.OrigShapeName}) } if ref.QueryName != "" { tags = append(tags, ShapeTag{"queryName", ref.QueryName}) } if ref.Shape.MemberRef.LocationName != "" { tags = append(tags, ShapeTag{"locationNameList", ref.Shape.MemberRef.LocationName}) } if ref.Shape.KeyRef.LocationName != "" { tags = append(tags, ShapeTag{"locationNameKey", ref.Shape.KeyRef.LocationName}) } if ref.Shape.ValueRef.LocationName != "" { tags = append(tags, ShapeTag{"locationNameValue", ref.Shape.ValueRef.LocationName}) } if ref.Shape.Min > 0 { tags = append(tags, ShapeTag{"min", fmt.Sprintf("%v", ref.Shape.Min)}) } if ref.Deprecated \|\| ref.Shape.Deprecated { tags = append(tags, ShapeTag{"deprecated", "true"}) } // All shapes have a type tags = append(tags, ShapeTag{"type", ref.Shape.Type}) // embed the timestamp type for easier lookups if ref.Shape.Type == "timestamp" { if format := ref.GetTimestampFormat(); len(format) > 0 { tags = append(tags, ShapeTag{ Key: "timestampFormat", Val: format, }) } } // Value that is encoded as a header that needs to be base64 encoded if ref.SuppressedJSONValue && location == "header" { tags = append(tags, ShapeTag{"suppressedJSONValue", "true"}) } if ref.Shape.Flattened \|\| ref.Flattened { tags = append(tags, ShapeTag{"flattened", "true"}) } if ref.XMLAttribute { tags = append(tags, ShapeTag{"xmlAttribute", "true"}) } if isRequired { tags = append(tags, ShapeTag{"required", "true"}) } if ref.Shape.IsEnum() { tags = append(tags, ShapeTag{"enum", ref.ShapeName}) } else if ref.Shape.Type == "list" && ref.Shape.MemberRef.Shape.IsEnum() { tags = append(tags, ShapeTag{"enum", ref.Shape.MemberRef.ShapeName}) } if toplevel { if name := ref.Shape.PayloadRefName(); len(name) > 0 { tags = append(tags, ShapeTag{"payload", name}) } if ref.Shape.UsedAsInput && !ref.Shape.HasPayloadMembers() && ref.API.Metadata.Protocol == "rest-json" { tags = append(tags, ShapeTag{"nopayload", "true"}) } } if ref.XMLNamespace.Prefix != "" { tags = append(tags, ShapeTag{"xmlPrefix", ref.XMLNamespace.Prefix}) } else if ref.Shape.XMLNamespace.Prefix != "" { tags = append(tags, ShapeTag{"xmlPrefix", ref.Shape.XMLNamespace.Prefix}) } if ref.XMLNamespace.URI != "" { tags = append(tags, ShapeTag{"xmlURI", ref.XMLNamespace.URI}) } else if ref.Shape.XMLNamespace.URI != "" { tags = append(tags, ShapeTag{"xmlURI", ref.Shape.XMLNamespace.URI}) } if ref.IdempotencyToken \|\| ref.Shape.IdempotencyToken { tags = append(tags, ShapeTag{"idempotencyToken", "true"}) } if ref.Ignore { tags = append(tags, ShapeTag{"ignore", "true"}) } if ref.Shape.IsSensitive() { tags = append(tags, ShapeTag{"sensitive", "true"}) } return fmt.Sprintf("`%s`", tags) } // HasPayloadMembers returns if the shape has any members that will be // serialized to the payload of a API message. func (s Shape) HasPayloadMembers() bool { for _, ref := range s.MemberRefs { if ref.Location == "" && ref.Shape.Location == "" { return true } } return false } // IsSensitive checks whether the Shape itself is sensitive, or if the Shape is // a collection/map with a sensitive member. func (s Shape) IsSensitive() bool { if s.Sensitive { return true } if s.MemberRef.Shape != nil && s.MemberRef.Shape.Sensitive { return true } if s.ValueRef.Shape != nil && s.ValueRef.Shape.Sensitive { return true } return false } // Docstring returns the godocs formated documentation func (ref ShapeRef) Docstring() string { if ref.Documentation != "" { return strings.Trim(ref.Documentation, "\n ") } return ref.Shape.Docstring() } // Docstring returns the godocs formated documentation func (s Shape) Docstring() string { return strings.Trim(s.Documentation, "\n ") } // IndentedDocstring is the indented form of the doc string. func (ref ShapeRef) IndentedDocstring() string { doc := ref.Docstring() return strings.Replace(doc, "// ", "// ", -1) } var goCodeStringerTmpl = template.Must(template.New("goCodeStringerTmpl").Parse(` // String returns the string representation. // // API parameter values that are decorated as "sensitive" in the API will not // be included in the string output. The member name will be present, but the // value will be replaced with "sensitive". func (s {{ $.ShapeName }}) String() string { return awsutil.Prettify(s) } // GoString returns the string representation. // // API parameter values that are decorated as "sensitive" in the API will not // be included in the string output. The member name will be present, but the // value will be replaced with "sensitive". func (s {{ $.ShapeName }}) GoString() string { return s.String() } `)) // GoCodeStringers renders the Stringers for API input/output shapes func (s Shape) GoCodeStringers() string { w := bytes.Buffer{} if err := goCodeStringerTmpl.Execute(&w, s); err != nil { panic(fmt.Sprintln("Unexpected error executing GoCodeStringers template", err)) } return w.String() } var enumStrip = regexp.MustCompile(`[^a-zA-Z0-9_:\./-]`) var enumDelims = regexp.MustCompile(`[-_:\./]+`) var enumCamelCase = regexp.MustCompile(`([a-z])([A-Z])`) // EnumName returns the Nth enum in the shapes Enum list func (s Shape) EnumName(n int) string { enum := s.Enum[n] enum = enumStrip.ReplaceAllLiteralString(enum, "") enum = enumCamelCase.ReplaceAllString(enum, "$1-$2") parts := enumDelims.Split(enum, -1) for i, v := range parts { v = strings.ToLower(v) parts[i] = "" if len(v) > 0 { parts[i] = strings.ToUpper(v[0:1]) } if len(v) > 1 { parts[i] += v[1:] } } enum = strings.Join(parts, "") enum = strings.ToUpper(enum[0:1]) + enum[1:] return enum } // NestedShape returns the shape pointer value for the shape which is nested // under the current shape. If the shape is not nested nil will be returned. // // strucutures, the current shape is returned // map: the value shape of the map is returned // list: the element shape of the list is returned func (s Shape) NestedShape() Shape { var nestedShape Shape switch s.Type { case "structure": nestedShape = s case "map": nestedShape = s.ValueRef.Shape case "list": nestedShape = s.MemberRef.Shape } return nestedShape } var structShapeTmpl = func() template.Template { shapeTmpl := template.Must( template.New("structShapeTmpl"). Funcs(template.FuncMap{ "GetDeprecatedMsg": getDeprecatedMessage, "TrimExportedMembers": func(s Shape) map[string]ShapeRef { members := map[string]ShapeRef{} for name, ref := range s.MemberRefs { if ref.Shape.IsEventStream { continue } members[name] = ref } return members }, }). Parse(structShapeTmplDef), ) template.Must( shapeTmpl.AddParseTree( "eventStreamEventShapeTmpl", eventStreamEventShapeTmpl.Tree), ) template.Must( shapeTmpl.AddParseTree( "exceptionShapeMethodTmpl", exceptionShapeMethodTmpl.Tree), ) shapeTmpl.Funcs(eventStreamEventShapeTmplFuncs) template.Must( shapeTmpl.AddParseTree( "hostLabelsShapeTmpl", hostLabelsShapeTmpl.Tree), ) template.Must( shapeTmpl.AddParseTree( "endpointARNShapeTmpl", endpointARNShapeTmpl.Tree), ) template.Must( shapeTmpl.AddParseTree( "outpostIDShapeTmpl", outpostIDShapeTmpl.Tree), ) template.Must( shapeTmpl.AddParseTree( "accountIDWithARNShapeTmpl", accountIDWithARNShapeTmpl.Tree), ) return shapeTmpl }() const structShapeTmplDef = ` {{ $.Docstring }} {{ if $.Deprecated -}} {{ if $.Docstring -}} // {{ end -}} // Deprecated: {{ GetDeprecatedMsg $.DeprecatedMsg $.ShapeName }} {{ end -}} type {{ $.ShapeName }} struct { _ struct{} {{ $.GoTags true false }} {{- if $.Exception }} {{- $_ := $.API.AddSDKImport "private/protocol" }} RespMetadata protocol.ResponseMetadata` + "`json:\"-\" xml:\"-\"`" + ` {{- if $.API.Metadata.AWSQueryCompatible }} Code_ string {{- end }} {{- end }} {{- if $.OutputEventStreamAPI }} {{ $.OutputEventStreamAPI.OutputMemberName }} {{ $.OutputEventStreamAPI.Name }} {{- end }} {{- range $name, $elem := (TrimExportedMembers $) }} {{ $isBlob := $.WillRefBeBase64Encoded $name -}} {{ $isRequired := $.IsRequired $name -}} {{ $isSensitive := $elem.Shape.Sensitive -}} {{ $doc := $elem.Docstring -}} {{ if $doc -}} {{ $doc }} {{ if $elem.Deprecated -}} // // Deprecated: {{ GetDeprecatedMsg $elem.DeprecatedMsg $name }} {{ end -}} {{ end -}} {{ if $isSensitive -}} {{ if $doc -}} // {{ end -}} // {{ $name }} is a sensitive parameter and its value will be // replaced with "sensitive" in string returned by {{ $.ShapeName }}'s // String and GoString methods. {{ end -}} {{ if $isBlob -}} {{ if $isSensitive -}} // {{ end -}} // {{ $name }} is automatically base64 encoded/decoded by the SDK. {{ end -}} {{ if $isRequired -}} {{ if or $doc $isBlob -}} // {{ end -}} // {{ $name }} is a required field {{ end -}} {{ $name }} {{ $.GoStructType $name $elem }} {{ $elem.GoTags false $isRequired }} {{- end }} } {{- if not $.API.NoStringerMethods }} {{ $.GoCodeStringers }} {{- end }} {{- if not (or $.API.NoValidataShapeMethods $.Exception) }} {{- if $.Validations }} {{ $.Validations.GoCode $ }} {{- end }} {{- end }} {{- if not (or $.API.NoGenStructFieldAccessors $.Exception) }} {{- $builderShapeName := print $.ShapeName }} {{- range $name, $elem := (TrimExportedMembers $) }} // Set{{ $name }} sets the {{ $name }} field's value. func (s {{ $builderShapeName }}) Set{{ $name }}(v {{ $.GoStructValueType $name $elem }}) {{ $builderShapeName }} { {{- if $elem.UseIndirection }} s.{{ $name }} = &v {{- else }} s.{{ $name }} = v {{- end }} return s } {{- if $elem.GenerateGetter }} func (s {{ $builderShapeName }}) get{{ $name }}() (v {{ $.GoStructValueType $name $elem }}) { {{- if $elem.UseIndirection }} if s.{{ $name }} == nil { return v } return s.{{ $name }} {{- else }} return s.{{ $name }} {{- end }} } {{- end }} {{- end }} {{- end }} {{- if $.OutputEventStreamAPI }} {{- $esMemberName := $.OutputEventStreamAPI.OutputMemberName }} {{- if $.OutputEventStreamAPI.Legacy }} func (s {{ $.ShapeName }}) Set{{ $esMemberName }}(v {{ $.OutputEventStreamAPI.Name }}) {{ $.ShapeName }} { s.{{ $esMemberName }} = v return s } func (s {{ $.ShapeName }}) Get{{ $esMemberName }}() {{ $.OutputEventStreamAPI.Name }} { return s.{{ $esMemberName }} } {{- end }} // GetStream returns the type to interact with the event stream. func (s {{ $.ShapeName }}) GetStream() {{ $.OutputEventStreamAPI.Name }} { return s.{{ $esMemberName }} } {{- end }} {{- if $.EventFor }} {{ template "eventStreamEventShapeTmpl" $ }} {{- end }} {{- if and $.Exception (or $.API.WithGeneratedTypedErrors $.EventFor) }} {{ template "exceptionShapeMethodTmpl" $ }} {{- end }} {{- if $.HasHostLabelMembers }} {{ template "hostLabelsShapeTmpl" $ }} {{- end }} {{- if $.HasEndpointARNMember }} {{ template "endpointARNShapeTmpl" $ }} {{- end }} {{- if $.HasOutpostIDMember }} {{ template "outpostIDShapeTmpl" $ }} {{- end }} {{- if $.HasAccountIdMemberWithARN }} {{ template "accountIDWithARNShapeTmpl" $ }} {{- end }} ` var exceptionShapeMethodTmpl = template.Must( template.New("exceptionShapeMethodTmpl").Parse(` {{- $_ := $.API.AddImport "fmt" }} {{/* TODO allow service custom input to be used /}} func newError{{ $.ShapeName }}(v protocol.ResponseMetadata) error { return &{{ $.ShapeName }}{ RespMetadata: v, } } {{- if $.API.Metadata.AWSQueryCompatible }} func newQueryCompatibleError{{ $.ShapeName }}(v protocol.ResponseMetadata, code string) error { return &{{ $.ShapeName }}{ RespMetadata: v, Code_: &code, } } {{- end }} // Code returns the exception type name. func (s {{ $.ShapeName }}) Code() string { {{- if $.API.Metadata.AWSQueryCompatible }} if s.Code_ != nil { return s.Code_ } {{- end }} return "{{ $.ErrorName }}" } // Message returns the exception's message. func (s {{ $.ShapeName }}) Message() string { {{- if index $.MemberRefs "Message_" }} if s.Message_ != nil { return s.Message_ } {{ end -}} return "" } // OrigErr always returns nil, satisfies awserr.Error interface. func (s {{ $.ShapeName }}) OrigErr() error { return nil } func (s {{ $.ShapeName }}) Error() string { {{- if or (and (eq (len $.MemberRefs) 1) (not (index $.MemberRefs "Message_"))) (gt (len $.MemberRefs) 1) }} return fmt.Sprintf("%s: %s\n%s", s.Code(), s.Message(), s.String()) {{- else }} return fmt.Sprintf("%s: %s", s.Code(), s.Message()) {{- end }} } // Status code returns the HTTP status code for the request's response error. func (s {{ $.ShapeName }}) StatusCode() int { return s.RespMetadata.StatusCode } // RequestID returns the service's response RequestID for request. func (s {{ $.ShapeName }}) RequestID() string { return s.RespMetadata.RequestID } `)) var enumShapeTmpl = template.Must(template.New("EnumShape").Parse(` {{ $.Docstring }} const ( {{ range $index, $elem := $.Enum -}} {{ $name := index $.EnumConsts $index -}} // {{ $name }} is a {{ $.ShapeName }} enum value {{ $name }} = "{{ $elem }}" {{ end }} ) {{/ Enum iterators use non-idomatic _Values suffix to avoid naming collisions with other generated types, and enum values /}} // {{ $.ShapeName }}_Values returns all elements of the {{ $.ShapeName }} enum func {{ $.ShapeName }}_Values() []string { return []string{ {{ range $index, $elem := $.Enum -}} {{ index $.EnumConsts $index }}, {{ end }} } } `)) // GoCode returns the rendered Go code for the Shape. func (s Shape) GoCode() string { w := &bytes.Buffer{} switch { case s.IsEventStream: if err := renderEventStreamShape(w, s); err != nil { panic( fmt.Sprintf( "failed to generate eventstream API shape, %s, %v", s.ShapeName, err), ) } case s.Type == "structure": if err := structShapeTmpl.Execute(w, s); err != nil { panic( fmt.Sprintf( "Failed to generate struct shape %s, %v", s.ShapeName, err), ) } case s.IsEnum(): if err := enumShapeTmpl.Execute(w, s); err != nil { panic( fmt.Sprintf( "Failed to generate enum shape %s, %v", s.ShapeName, err), ) } default: panic(fmt.Sprintln("Cannot generate toplevel shape for", s.Type)) } return w.String() } // IsEnum returns whether this shape is an enum list func (s Shape) IsEnum() bool { return s.Type == "string" && len(s.Enum) > 0 } // IsRequired returns if member is a required field. Required fields are fields // marked as required, hostLabels, or location of uri path. func (s Shape) IsRequired(member string) bool { ref, ok := s.MemberRefs[member] if !ok { panic(fmt.Sprintf( "attempted to check required for unknown member, %s.%s", s.ShapeName, member, )) } if ref.IdempotencyToken \|\| ref.Shape.IdempotencyToken { return false } if ref.Location == "uri" \|\| ref.HostLabel { return true } for _, n := range s.Required { if n == member { if ref.Shape.IsEventStream { return false } return true } } return false } // IsInternal returns whether the shape was defined in this package func (s Shape) IsInternal() bool { return s.resolvePkg == "" } // removeRef removes a shape reference from the list of references this // shape is used in. func (s Shape) removeRef(ref ShapeRef) { r := s.refs for i := 0; i < len(r); i++ { if r[i] == ref { j := i + 1 copy(r[i:], r[j:]) for k, n := len(r)-j+i, len(r); k < n; k++ { r[k] = nil // free up the end of the list } // for k s.refs = r[:len(r)-j+i] break } } } func (s Shape) WillRefBeBase64Encoded(refName string) bool { payloadRefName := s.Payload if payloadRefName == refName { return false } ref, ok := s.MemberRefs[refName] if !ok { panic(fmt.Sprintf("shape %s does not contain %q refName", s.ShapeName, refName)) } return ref.Shape.Type == "blob" } // Clone returns a cloned version of the shape with all references clones. // // Does not clone EventStream or Validate related values. func (s Shape) Clone(newName string) Shape { if s.AliasedShapeName { panic(fmt.Sprintf("attempted to clone and rename %s, but flagged as aliased", s.ShapeName)) } n := new(Shape) n = s debugLogger.Logln("cloning", s.ShapeName, "to", newName) n.MemberRefs = map[string]ShapeRef{} for k, r := range s.MemberRefs { nr := new(ShapeRef) nr = r nr.Shape.refs = append(nr.Shape.refs, nr) n.MemberRefs[k] = nr } if n.MemberRef.Shape != nil { n.MemberRef.Shape.refs = append(n.MemberRef.Shape.refs, &n.MemberRef) } if n.KeyRef.Shape != nil { n.KeyRef.Shape.refs = append(n.KeyRef.Shape.refs, &n.KeyRef) } if n.ValueRef.Shape != nil { n.ValueRef.Shape.refs = append(n.ValueRef.Shape.refs, &n.ValueRef) } n.refs = []ShapeRef{} n.Required = append([]string{}, n.Required...) n.Enum = append([]string{}, n.Enum...) n.EnumConsts = append([]string{}, n.EnumConsts...) n.API.Shapes[newName] = n n.ShapeName = newName n.OrigShapeName = s.OrigShapeName return n }	30.37 KB	2025-05-25 12:27
📄 shape_alias.go package api var shapeNameAliases = map[string]map[string]string{ "APIGateway": { "RequestValidator": "UpdateRequestValidatorOutput", "VpcLink": "UpdateVpcLinkOutput", "GatewayResponse": "UpdateGatewayResponseOutput", }, "Lambda": { "Concurrency": "PutFunctionConcurrencyOutput", }, "Neptune": { "DBClusterParameterGroupNameMessage": "ResetDBClusterParameterGroupOutput", "DBParameterGroupNameMessage": "ResetDBParameterGroupOutput", }, "RDS": { "DBClusterBacktrack": "BacktrackDBClusterOutput", }, }	540 B	2025-05-25 12:27
📄 shape_validation.go //go:build codegen // +build codegen package api import ( "bytes" "fmt" "text/template" ) // A ShapeValidationType is the type of validation that a shape needs type ShapeValidationType int const ( // ShapeValidationRequired states the shape must be set ShapeValidationRequired = iota // ShapeValidationMinVal states the shape must have at least a number of // elements, or for numbers a minimum value ShapeValidationMinVal // ShapeValidationNested states the shape has nested values that need // to be validated ShapeValidationNested ) // A ShapeValidation contains information about a shape and the type of validation // that is needed type ShapeValidation struct { // Name of the shape to be validated Name string // Reference to the shape within the context the shape is referenced Ref ShapeRef // Type of validation needed Type ShapeValidationType } var validationGoCodeTmpls = template.Must( template.New("validationGoCodeTmpls"). Funcs(template.FuncMap{ "getMin": func(ref ShapeRef) float64 { if !ref.CanBeEmpty() && ref.Shape.Min <= 0 { return 1 } return ref.Shape.Min }, }). Parse(` {{ define "requiredValue" -}} if s.{{ .Name }} == nil { invalidParams.Add(request.NewErrParamRequired("{{ .Name }}")) } {{- end }} {{ define "minLen" -}} {{- $min := getMin .Ref -}} if s.{{ .Name }} != nil && len(s.{{ .Name }}) < {{ $min }} { invalidParams.Add(request.NewErrParamMinLen("{{ .Name }}", {{ $min }})) } {{- end }} {{ define "minLenString" -}} {{- $min := getMin .Ref -}} if s.{{ .Name }} != nil && len(s.{{ .Name }}) < {{ $min }} { invalidParams.Add(request.NewErrParamMinLen("{{ .Name }}", {{ $min }})) } {{- end }} {{ define "minVal" -}} {{- $min := getMin .Ref -}} if s.{{ .Name }} != nil && s.{{ .Name }} < {{ $min }} { invalidParams.Add(request.NewErrParamMinValue("{{ .Name }}", {{ $min }})) } {{- end }} {{ define "nestedMapList" -}} if s.{{ .Name }} != nil { for i, v := range s.{{ .Name }} { if v == nil { continue } if err := v.Validate(); err != nil { invalidParams.AddNested(fmt.Sprintf("%s[%v]", "{{ .Name }}", i), err.(request.ErrInvalidParams)) } } } {{- end }} {{ define "nestedStruct" -}} if s.{{ .Name }} != nil { if err := s.{{ .Name }}.Validate(); err != nil { invalidParams.AddNested("{{ .Name }}", err.(request.ErrInvalidParams)) } } {{- end }} `)) // GoCode returns the generated Go code for the Shape with its validation type. func (sv ShapeValidation) GoCode() string { var err error w := &bytes.Buffer{} switch sv.Type { case ShapeValidationRequired: err = validationGoCodeTmpls.ExecuteTemplate(w, "requiredValue", sv) case ShapeValidationMinVal: switch sv.Ref.Shape.Type { case "list", "map", "blob": err = validationGoCodeTmpls.ExecuteTemplate(w, "minLen", sv) case "string": err = validationGoCodeTmpls.ExecuteTemplate(w, "minLenString", sv) case "integer", "long", "float", "double": err = validationGoCodeTmpls.ExecuteTemplate(w, "minVal", sv) default: panic(fmt.Sprintf("ShapeValidation.GoCode, %s's type %s, no min value handling", sv.Name, sv.Ref.Shape.Type)) } case ShapeValidationNested: switch sv.Ref.Shape.Type { case "map", "list": err = validationGoCodeTmpls.ExecuteTemplate(w, "nestedMapList", sv) default: err = validationGoCodeTmpls.ExecuteTemplate(w, "nestedStruct", sv) } default: panic(fmt.Sprintf("ShapeValidation.GoCode, %s's type %d, unknown validation type", sv.Name, sv.Type)) } if err != nil { panic(fmt.Sprintf("ShapeValidation.GoCode failed, err: %v", err)) } return w.String() } // A ShapeValidations is a collection of shape validations needed nested within // a parent shape type ShapeValidations []ShapeValidation var validateShapeTmpl = template.Must(template.New("ValidateShape").Parse(` // Validate inspects the fields of the type to determine if they are valid. func (s {{ .Shape.ShapeName }}) Validate() error { invalidParams := request.ErrInvalidParams{Context: "{{ .Shape.ShapeName }}"} {{ range $_, $v := .Validations -}} {{ $v.GoCode }} {{ end }} if invalidParams.Len() > 0 { return invalidParams } return nil } `)) // GoCode generates the Go code needed to perform validations for the // shape and its nested fields. func (vs ShapeValidations) GoCode(shape Shape) string { buf := &bytes.Buffer{} validateShapeTmpl.Execute(buf, map[string]interface{}{ "Shape": shape, "Validations": vs, }) return buf.String() } // Has returns true or false if the ShapeValidations already contains the // the reference and validation type. func (vs ShapeValidations) Has(ref *ShapeRef, typ ShapeValidationType) bool { for _, v := range vs { if v.Ref == ref && v.Type == typ { return true } } return false }	4.68 KB	2025-05-25 12:27
📄 shape_value_builder.go //go:build codegen // +build codegen package api import ( "encoding/base64" "encoding/json" "fmt" "reflect" "sort" "strings" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/private/protocol" ) // ShapeValueBuilder provides the logic to build the nested values for a shape. // Base64BlobValues is true if the blob field in shapeRef.Shape.Type is base64 // encoded. type ShapeValueBuilder struct { // Specifies if API shapes modeled as blob types, input values are base64 // encoded or not, and strings values instead. Base64BlobValues bool // The helper that will provide the logic and formated code to convert a // timestamp input value into a Go time.Time. ParseTimeString func(ref ShapeRef, memberName, v string) string } // NewShapeValueBuilder returns an initialized ShapeValueBuilder for generating // API shape types initialized with values. func NewShapeValueBuilder() ShapeValueBuilder { return ShapeValueBuilder{ParseTimeString: parseUnixTimeString} } // BuildShape will recursively build the referenced shape based on the json // object provided. isMap will dictate how the field name is specified. If // isMap is true, we will expect the member name to be quotes like "Foo". func (b ShapeValueBuilder) BuildShape(ref ShapeRef, shapes map[string]interface{}, isMap bool) string { order := make([]string, len(shapes)) for k := range shapes { order = append(order, k) } sort.Strings(order) ret := "" for _, name := range order { if name == "" { continue } shape := shapes[name] // If the shape isn't a map, we want to export the value, since every field // defined in our shapes are exported. if len(name) > 0 && !isMap && strings.ToLower(name[0:1]) == name[0:1] { name = strings.Title(name) } memName := name passRef := ref.Shape.MemberRefs[name] if isMap { memName = fmt.Sprintf("%q", memName) passRef = &ref.Shape.ValueRef } switch v := shape.(type) { case map[string]interface{}: ret += b.BuildComplex(name, memName, passRef, ref.Shape, v) case []interface{}: ret += b.BuildList(name, memName, passRef, v) default: ret += b.BuildScalar(name, memName, passRef, v, ref.Shape.Payload == name) } } return ret } // BuildList will construct a list shape based off the service's definition of // that list. func (b ShapeValueBuilder) BuildList(name, memName string, ref ShapeRef, v []interface{}) string { ret := "" if len(v) == 0 \|\| ref == nil { return "" } passRef := &ref.Shape.MemberRef ret += fmt.Sprintf("%s: %s {\n", memName, b.GoType(ref, false)) ret += b.buildListElements(passRef, v) ret += "},\n" return ret } func (b ShapeValueBuilder) buildListElements(ref ShapeRef, v []interface{}) string { if len(v) == 0 \|\| ref == nil { return "" } ret := "" format := "" isComplex := false isList := false // get format for atomic type. If it is not an atomic type, // get the element. switch v[0].(type) { case string: format = "%s" case bool: format = "%t" case float64: switch ref.Shape.Type { case "integer", "int64", "long": format = "%d" default: format = "%f" } case []interface{}: isList = true case map[string]interface{}: isComplex = true } for _, elem := range v { if isComplex { ret += fmt.Sprintf("{\n%s\n},\n", b.BuildShape(ref, elem.(map[string]interface{}), ref.Shape.Type == "map")) } else if isList { ret += fmt.Sprintf("{\n%s\n},\n", b.buildListElements(&ref.Shape.MemberRef, elem.([]interface{}))) } else { switch ref.Shape.Type { case "integer", "int64", "long": elem = int(elem.(float64)) } ret += fmt.Sprintf("%s,\n", getValue(ref.Shape.Type, fmt.Sprintf(format, elem))) } } return ret } // BuildScalar will build atomic Go types. func (b ShapeValueBuilder) BuildScalar(name, memName string, ref ShapeRef, shape interface{}, isPayload bool) string { if ref == nil \|\| ref.Shape == nil { return "" } switch v := shape.(type) { case bool: return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%t", v)) case int: if ref.Shape.Type == "timestamp" { return b.ParseTimeString(ref, memName, fmt.Sprintf("%d", v)) } return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%d", v)) case float64: dataType := ref.Shape.Type if dataType == "timestamp" { return b.ParseTimeString(ref, memName, fmt.Sprintf("%f", v)) } if dataType == "integer" \|\| dataType == "int64" \|\| dataType == "long" { return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%d", int(shape.(float64)))) } return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%f", v)) case string: t := ref.Shape.Type switch t { case "timestamp": return b.ParseTimeString(ref, memName, fmt.Sprintf("%s", v)) case "jsonvalue": return fmt.Sprintf("%s: %#v,\n", memName, parseJSONString(v)) case "blob": if (ref.Streaming \|\| ref.Shape.Streaming) && isPayload { return fmt.Sprintf("%s: aws.ReadSeekCloser(strings.NewReader(%q)),\n", memName, v) } if b.Base64BlobValues { decodedBlob, err := base64.StdEncoding.DecodeString(v) if err != nil { panic(fmt.Errorf("Failed to decode string: %v", err)) } return fmt.Sprintf("%s: []byte(%q),\n", memName, decodedBlob) } return fmt.Sprintf("%s: []byte(%q),\n", memName, v) default: return convertToCorrectType(memName, t, v) } default: panic(fmt.Errorf("Unsupported scalar type: %v", reflect.TypeOf(v))) } } // BuildComplex will build the shape's value for complex types such as structs, // and maps. func (b ShapeValueBuilder) BuildComplex(name, memName string, ref ShapeRef, parent Shape, v map[string]interface{}) string { switch parent.Type { case "structure": if ref.Shape.Type == "map" { return fmt.Sprintf(`%s: %s{ %s }, `, memName, b.GoType(ref, true), b.BuildShape(ref, v, true)) } else { // Don't try to generate for members not actually modeled in the API if _, ok := parent.MemberRefs[memName]; !ok { return "" } return fmt.Sprintf(`%s: &%s{ %s }, `, memName, b.GoType(ref, true), b.BuildShape(ref, v, false)) } case "map": if ref.Shape.Type == "map" { return fmt.Sprintf(`%q: %s{ %s }, `, name, b.GoType(ref, false), b.BuildShape(ref, v, true)) } else { return fmt.Sprintf(`%s: &%s{ %s }, `, memName, b.GoType(ref, true), b.BuildShape(ref, v, false)) } default: panic(fmt.Sprintf("Expected complex type but received %q", ref.Shape.Type)) } } // GoType returns the string of the shape's Go type identifier. func (b ShapeValueBuilder) GoType(ref ShapeRef, elem bool) string { if ref.Shape.Type != "structure" && ref.Shape.Type != "list" && ref.Shape.Type != "map" { // Scalars are always pointers. return ref.GoTypeWithPkgName() } prefix := "" if ref.Shape.Type == "list" { ref = &ref.Shape.MemberRef prefix = "[]" } if elem { return prefix + ref.Shape.GoTypeWithPkgNameElem() } return prefix + ref.GoTypeWithPkgName() } // parseJSONString a json string and returns aws.JSONValue. func parseJSONString(input string) aws.JSONValue { var v aws.JSONValue if err := json.Unmarshal([]byte(input), &v); err != nil { panic(fmt.Sprintf("unable to unmarshal JSONValue, %v", err)) } return v } // InlineParseModeledTime returns the string of an inline function which // returns time. func inlineParseModeledTime(format, v string) string { const formatTimeTmpl = `func() time.Time{ v, err := protocol.ParseTime("%s", "%s") if err != nil { panic(err) } return &v }()` return fmt.Sprintf(formatTimeTmpl, format, v) } // parseUnixTimeString returns a string which assigns the value of a time // member using an inline function Defined inline function parses time in // UnixTimeFormat. func parseUnixTimeString(ref ShapeRef, memName, v string) string { ref.API.AddSDKImport("private/protocol") return fmt.Sprintf("%s: %s,\n", memName, inlineParseModeledTime(protocol.UnixTimeFormatName, v)) }	7.83 KB	2025-05-25 12:27
📄 shapetag_test.go //go:build 1.6 && codegen // +build 1.6,codegen package api_test import ( "testing" "github.com/aws/aws-sdk-go/private/model/api" ) func TestShapeTagJoin(t *testing.T) { s := api.ShapeTags{ {Key: "location", Val: "query"}, {Key: "locationName", Val: "abc"}, {Key: "type", Val: "string"}, } expected := `location:"query" locationName:"abc" type:"string"` o := s.Join(" ") o2 := s.String() if expected != o { t.Errorf("Expected %s, but received %s", expected, o) } if expected != o2 { t.Errorf("Expected %s, but received %s", expected, o2) } }	569 B	2025-05-25 12:27
📄 smoke.go //go:build codegen // +build codegen package api import ( "bytes" "encoding/json" "fmt" "os" "sort" "text/template" ) // SmokeTestSuite defines the test suite for smoke tests. type SmokeTestSuite struct { Version int `json:"version"` DefaultRegion string `json:"defaultRegion"` TestCases []SmokeTestCase `json:"testCases"` } // SmokeTestCase provides the definition for a integration smoke test case. type SmokeTestCase struct { OpName string `json:"operationName"` Input map[string]interface{} `json:"input"` ExpectErr bool `json:"errorExpectedFromService"` } var smokeTestsCustomizations = map[string]func(SmokeTestSuite) error{ "sts": stsSmokeTestCustomization, "waf": wafSmokeTestCustomization, "wafregional": wafRegionalSmokeTestCustomization, "iotdataplane": iotDataPlaneSmokeTestCustomization, "opsworks": removeSmokeTests, "cloudsearch": removeSmokeTests, } func iotDataPlaneSmokeTestCustomization(suite SmokeTestSuite) error { suite.TestCases = []SmokeTestCase{} return nil } func removeSmokeTests(suite SmokeTestSuite) error { suite.TestCases = []SmokeTestCase{} return nil } func wafSmokeTestCustomization(suite SmokeTestSuite) error { return filterWAFCreateSqlInjectionMatchSet(suite) } func wafRegionalSmokeTestCustomization(suite SmokeTestSuite) error { return filterWAFCreateSqlInjectionMatchSet(suite) } func filterWAFCreateSqlInjectionMatchSet(suite SmokeTestSuite) error { const createSqlInjectionMatchSetOp = "CreateSqlInjectionMatchSet" var testCases []SmokeTestCase for _, testCase := range suite.TestCases { if testCase.OpName == createSqlInjectionMatchSetOp { continue } testCases = append(testCases, testCase) } suite.TestCases = testCases return nil } func stsSmokeTestCustomization(suite SmokeTestSuite) error { const getSessionTokenOp = "GetSessionToken" const getCallerIdentityOp = "GetCallerIdentity" opTestMap := make(map[string][]SmokeTestCase) for _, testCase := range suite.TestCases { opTestMap[testCase.OpName] = append(opTestMap[testCase.OpName], testCase) } if _, ok := opTestMap[getSessionTokenOp]; ok { delete(opTestMap, getSessionTokenOp) } if _, ok := opTestMap[getCallerIdentityOp]; !ok { opTestMap[getCallerIdentityOp] = append(opTestMap[getCallerIdentityOp], SmokeTestCase{ OpName: getCallerIdentityOp, Input: map[string]interface{}{}, ExpectErr: false, }) } var testCases []SmokeTestCase var keys []string for name := range opTestMap { keys = append(keys, name) } sort.Strings(keys) for _, name := range keys { testCases = append(testCases, opTestMap[name]...) } suite.TestCases = testCases return nil } // BuildInputShape returns the Go code as a string for initializing the test // case's input shape. func (c SmokeTestCase) BuildInputShape(ref ShapeRef) string { b := NewShapeValueBuilder() return fmt.Sprintf("&%s{\n%s\n}", b.GoType(ref, true), b.BuildShape(ref, c.Input, false), ) } // AttachSmokeTests attaches the smoke test cases to the API model. func (a API) AttachSmokeTests(filename string) error { f, err := os.Open(filename) if err != nil { return fmt.Errorf("failed to open smoke tests %s, err: %v", filename, err) } defer f.Close() if err := json.NewDecoder(f).Decode(&a.SmokeTests); err != nil { return fmt.Errorf("failed to decode smoke tests %s, err: %v", filename, err) } if v := a.SmokeTests.Version; v != 1 { return fmt.Errorf("invalid smoke test version, %d", v) } if fn, ok := smokeTestsCustomizations[a.PackageName()]; ok { if err := fn(&a.SmokeTests); err != nil { return err } } return nil } // APISmokeTestsGoCode returns the Go Code string for the smoke tests. func (a API) APISmokeTestsGoCode() string { w := bytes.NewBuffer(nil) a.resetImports() a.AddImport("context") a.AddImport("testing") a.AddImport("time") a.AddSDKImport("aws") a.AddSDKImport("aws/request") a.AddSDKImport("aws/awserr") a.AddSDKImport("aws/request") a.AddSDKImport("awstesting/integration") a.AddImport(a.ImportPath()) smokeTests := struct { API API SmokeTestSuite }{ API: a, SmokeTestSuite: a.SmokeTests, } if err := smokeTestTmpl.Execute(w, smokeTests); err != nil { panic(fmt.Sprintf("failed to create smoke tests, %v", err)) } ignoreImports := ` var _ aws.Config var _ awserr.Error var _ request.Request ` return a.importsGoCode() + ignoreImports + w.String() } var smokeTestTmpl = template.Must(template.New(`smokeTestTmpl`).Parse(` {{- range $i, $testCase := $.TestCases }} {{- $op := index $.API.Operations $testCase.OpName }} {{- if $op }} func TestInteg_{{ printf "%02d" $i }}_{{ $op.ExportedName }}(t testing.T) { ctx, cancelFn := context.WithTimeout(context.Background(), 5 time.Second) defer cancelFn() sess := integration.SessionWithDefaultRegion("{{ $.DefaultRegion }}") svc := {{ $.API.PackageName }}.New(sess) params := {{ $testCase.BuildInputShape $op.InputRef }} _, err := svc.{{ $op.ExportedName }}WithContext(ctx, params, func(r request.Request) { r.Handlers.Validate.RemoveByName("core.ValidateParametersHandler") }) {{- if $testCase.ExpectErr }} if err == nil { t.Fatalf("expect request to fail") } aerr, ok := err.(awserr.RequestFailure) if !ok { t.Fatalf("expect awserr, was %T", err) } if len(aerr.Code()) == 0 { t.Errorf("expect non-empty error code") } if len(aerr.Message()) == 0 { t.Errorf("expect non-empty error message") } if v := aerr.Code(); v == request.ErrCodeSerialization { t.Errorf("expect API error code got serialization failure") } {{- else }} if err != nil { t.Errorf("expect no error, got %v", err) } {{- end }} } {{- end }} {{- end }} `))	5.69 KB	2025-05-25 12:27
📄 waiters.go //go:build codegen // +build codegen package api import ( "bytes" "encoding/json" "fmt" "os" "sort" "strings" "text/template" ) // WaiterAcceptor is the acceptors defined in the model the SDK will use // to wait on resource states with. type WaiterAcceptor struct { State string Matcher string Argument string Expected interface{} } // ExpectedString returns the string that was expected by the WaiterAcceptor func (a WaiterAcceptor) ExpectedString() string { switch a.Expected.(type) { case string: return fmt.Sprintf("%q", a.Expected) default: return fmt.Sprintf("%v", a.Expected) } } // A Waiter is an individual waiter definition. type Waiter struct { Name string Delay int MaxAttempts int OperationName string `json:"operation"` Operation Operation Acceptors []WaiterAcceptor } // WaitersGoCode generates and returns Go code for each of the waiters of // this API. func (a API) WaitersGoCode() string { var buf bytes.Buffer fmt.Fprintf(&buf, "import (\n%q\n\n%q\n%q\n)", "time", SDKImportRoot+"/aws", SDKImportRoot+"/aws/request", ) for _, w := range a.Waiters { buf.WriteString(w.GoCode()) } return buf.String() } // used for unmarshaling from the waiter JSON file type waiterDefinitions struct { API Waiters map[string]Waiter } // AttachWaiters reads a file of waiter definitions, and adds those to the API. // Will panic if an error occurs. func (a API) AttachWaiters(filename string) error { p := waiterDefinitions{API: a} f, err := os.Open(filename) defer f.Close() if err != nil { return err } err = json.NewDecoder(f).Decode(&p) if err != nil { return err } return p.setup() } func (p waiterDefinitions) setup() error { p.API.Waiters = []Waiter{} i, keys := 0, make([]string, len(p.Waiters)) for k := range p.Waiters { keys[i] = k i++ } sort.Strings(keys) for _, n := range keys { e := p.Waiters[n] n = p.ExportableName(n) e.Name = n e.OperationName = p.ExportableName(e.OperationName) e.Operation = p.API.Operations[e.OperationName] if e.Operation == nil { continue } p.API.Waiters = append(p.API.Waiters, e) } return nil } var waiterTmpls = template.Must(template.New("waiterTmpls").Funcs( template.FuncMap{ "titleCase": func(v string) string { return strings.Title(v) }, }, ).Parse(` {{ define "waiter"}} // WaitUntil{{ .Name }} uses the {{ .Operation.API.NiceName }} API operation // {{ .OperationName }} to wait for a condition to be met before returning. // If the condition is not met within the max attempt window, an error will // be returned. func (c {{ .Operation.API.StructName }}) WaitUntil{{ .Name }}(input {{ .Operation.InputRef.GoType }}) error { return c.WaitUntil{{ .Name }}WithContext(aws.BackgroundContext(), input) } // WaitUntil{{ .Name }}WithContext is an extended version of WaitUntil{{ .Name }}. // With the support for passing in a context and options to configure the // Waiter and the underlying request options. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c {{ .Operation.API.StructName }}) WaitUntil{{ .Name }}WithContext(` + `ctx aws.Context, input {{ .Operation.InputRef.GoType }}, opts ...request.WaiterOption) error { w := request.Waiter{ Name: "WaitUntil{{ .Name }}", MaxAttempts: {{ .MaxAttempts }}, Delay: request.ConstantWaiterDelay({{ .Delay }} * time.Second), Acceptors: []request.WaiterAcceptor{ {{ range $_, $a := .Acceptors }}{ State: request.{{ titleCase .State }}WaiterState, Matcher: request.{{ titleCase .Matcher }}WaiterMatch, {{- if .Argument }}Argument: "{{ .Argument }}",{{ end }} Expected: {{ .ExpectedString }}, }, {{ end }} }, Logger: c.Config.Logger, NewRequest: func(opts []request.Option) (request.Request, error) { var inCpy {{ .Operation.InputRef.GoType }} if input != nil { tmp := input inCpy = &tmp } req, _ := c.{{ .OperationName }}Request(inCpy) req.SetContext(ctx) req.ApplyOptions(opts...) return req, nil }, } w.ApplyOptions(opts...) return w.WaitWithContext(ctx) } {{- end }} {{ define "waiter interface" }} WaitUntil{{ .Name }}({{ .Operation.InputRef.GoTypeWithPkgName }}) error WaitUntil{{ .Name }}WithContext(aws.Context, {{ .Operation.InputRef.GoTypeWithPkgName }}, ...request.WaiterOption) error {{- end }} `)) // InterfaceSignature returns a string representing the Waiter's interface // function signature. func (w Waiter) InterfaceSignature() string { var buf bytes.Buffer if err := waiterTmpls.ExecuteTemplate(&buf, "waiter interface", w); err != nil { panic(err) } return strings.TrimSpace(buf.String()) } // GoCode returns the generated Go code for an individual waiter. func (w Waiter) GoCode() string { var buf bytes.Buffer if err := waiterTmpls.ExecuteTemplate(&buf, "waiter", w); err != nil { panic(err) } return buf.String() }	4.99 KB	2025-05-25 12:27

Edit File:

Terminal