repo_name stringlengths 1 52 | repo_creator stringclasses 6
values | programming_language stringclasses 4
values | code stringlengths 0 9.68M | num_lines int64 1 234k |
|---|---|---|---|---|
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Attaches one or more LF-tags to an existing resource.
func (c *Client) AddLFTagsToResource(ctx context.Context, params *AddLFTagsToResourceInput, optFns ...func(*Options)) (*AddLFTagsToResourceOutput, error) {
if params == nil {
params = &AddLFTagsToResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AddLFTagsToResource", params, optFns, c.addOperationAddLFTagsToResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AddLFTagsToResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type AddLFTagsToResourceInput struct {
// The LF-tags to attach to the resource.
//
// This member is required.
LFTags []types.LFTagPair
// The database, table, or column resource to which to attach an LF-tag.
//
// This member is required.
Resource *types.Resource
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type AddLFTagsToResourceOutput struct {
// A list of failures to tag the resource.
Failures []types.LFTagError
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAddLFTagsToResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAddLFTagsToResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAddLFTagsToResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpAddLFTagsToResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAddLFTagsToResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAddLFTagsToResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "AddLFTagsToResource",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Allows a caller to assume an IAM role decorated as the SAML user specified in
// the SAML assertion included in the request. This decoration allows Lake
// Formation to enforce access policies against the SAML users and groups. This API
// operation requires SAML federation setup in the caller’s account as it can only
// be called with valid SAML assertions. Lake Formation does not scope down the
// permission of the assumed role. All permissions attached to the role via the
// SAML federation setup will be included in the role session. This decorated role
// is expected to access data in Amazon S3 by getting temporary access from Lake
// Formation which is authorized via the virtual API GetDataAccess . Therefore, all
// SAML roles that can be assumed via AssumeDecoratedRoleWithSAML must at a
// minimum include lakeformation:GetDataAccess in their role policies. A typical
// IAM policy attached to such a role would look as follows:
func (c *Client) AssumeDecoratedRoleWithSAML(ctx context.Context, params *AssumeDecoratedRoleWithSAMLInput, optFns ...func(*Options)) (*AssumeDecoratedRoleWithSAMLOutput, error) {
if params == nil {
params = &AssumeDecoratedRoleWithSAMLInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AssumeDecoratedRoleWithSAML", params, optFns, c.addOperationAssumeDecoratedRoleWithSAMLMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AssumeDecoratedRoleWithSAMLOutput)
out.ResultMetadata = metadata
return out, nil
}
type AssumeDecoratedRoleWithSAMLInput struct {
// The Amazon Resource Name (ARN) of the SAML provider in IAM that describes the
// IdP.
//
// This member is required.
PrincipalArn *string
// The role that represents an IAM principal whose scope down policy allows it to
// call credential vending APIs such as GetTemporaryTableCredentials . The caller
// must also have iam:PassRole permission on this role.
//
// This member is required.
RoleArn *string
// A SAML assertion consisting of an assertion statement for the user who needs
// temporary credentials. This must match the SAML assertion that was issued to
// IAM. This must be Base64 encoded.
//
// This member is required.
SAMLAssertion *string
// The time period, between 900 and 43,200 seconds, for the timeout of the
// temporary credentials.
DurationSeconds *int32
noSmithyDocumentSerde
}
type AssumeDecoratedRoleWithSAMLOutput struct {
// The access key ID for the temporary credentials. (The access key consists of an
// access key ID and a secret key).
AccessKeyId *string
// The date and time when the temporary credentials expire.
Expiration *time.Time
// The secret key for the temporary credentials. (The access key consists of an
// access key ID and a secret key).
SecretAccessKey *string
// The session token for the temporary credentials.
SessionToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAssumeDecoratedRoleWithSAMLMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAssumeDecoratedRoleWithSAML{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAssumeDecoratedRoleWithSAML{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpAssumeDecoratedRoleWithSAMLValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAssumeDecoratedRoleWithSAML(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAssumeDecoratedRoleWithSAML(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "AssumeDecoratedRoleWithSAML",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Batch operation to grant permissions to the principal.
func (c *Client) BatchGrantPermissions(ctx context.Context, params *BatchGrantPermissionsInput, optFns ...func(*Options)) (*BatchGrantPermissionsOutput, error) {
if params == nil {
params = &BatchGrantPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchGrantPermissions", params, optFns, c.addOperationBatchGrantPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchGrantPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchGrantPermissionsInput struct {
// A list of up to 20 entries for resource permissions to be granted by batch
// operation to the principal.
//
// This member is required.
Entries []types.BatchPermissionsRequestEntry
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type BatchGrantPermissionsOutput struct {
// A list of failures to grant permissions to the resources.
Failures []types.BatchPermissionsFailureEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchGrantPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchGrantPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchGrantPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpBatchGrantPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchGrantPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opBatchGrantPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "BatchGrantPermissions",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Batch operation to revoke permissions from the principal.
func (c *Client) BatchRevokePermissions(ctx context.Context, params *BatchRevokePermissionsInput, optFns ...func(*Options)) (*BatchRevokePermissionsOutput, error) {
if params == nil {
params = &BatchRevokePermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchRevokePermissions", params, optFns, c.addOperationBatchRevokePermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchRevokePermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchRevokePermissionsInput struct {
// A list of up to 20 entries for resource permissions to be revoked by batch
// operation to the principal.
//
// This member is required.
Entries []types.BatchPermissionsRequestEntry
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type BatchRevokePermissionsOutput struct {
// A list of failures to revoke permissions to the resources.
Failures []types.BatchPermissionsFailureEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchRevokePermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchRevokePermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchRevokePermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpBatchRevokePermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchRevokePermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opBatchRevokePermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "BatchRevokePermissions",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Attempts to cancel the specified transaction. Returns an exception if the
// transaction was previously committed.
func (c *Client) CancelTransaction(ctx context.Context, params *CancelTransactionInput, optFns ...func(*Options)) (*CancelTransactionOutput, error) {
if params == nil {
params = &CancelTransactionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CancelTransaction", params, optFns, c.addOperationCancelTransactionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CancelTransactionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CancelTransactionInput struct {
// The transaction to cancel.
//
// This member is required.
TransactionId *string
noSmithyDocumentSerde
}
type CancelTransactionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCancelTransactionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCancelTransaction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCancelTransaction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCancelTransactionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCancelTransaction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCancelTransaction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "CancelTransaction",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Attempts to commit the specified transaction. Returns an exception if the
// transaction was previously aborted. This API action is idempotent if called
// multiple times for the same transaction.
func (c *Client) CommitTransaction(ctx context.Context, params *CommitTransactionInput, optFns ...func(*Options)) (*CommitTransactionOutput, error) {
if params == nil {
params = &CommitTransactionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CommitTransaction", params, optFns, c.addOperationCommitTransactionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CommitTransactionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CommitTransactionInput struct {
// The transaction to commit.
//
// This member is required.
TransactionId *string
noSmithyDocumentSerde
}
type CommitTransactionOutput struct {
// The status of the transaction.
TransactionStatus types.TransactionStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCommitTransactionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCommitTransaction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCommitTransaction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCommitTransactionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCommitTransaction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCommitTransaction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "CommitTransaction",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a data cell filter to allow one to grant access to certain columns on
// certain rows.
func (c *Client) CreateDataCellsFilter(ctx context.Context, params *CreateDataCellsFilterInput, optFns ...func(*Options)) (*CreateDataCellsFilterOutput, error) {
if params == nil {
params = &CreateDataCellsFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDataCellsFilter", params, optFns, c.addOperationCreateDataCellsFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDataCellsFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDataCellsFilterInput struct {
// A DataCellsFilter structure containing information about the data cells filter.
//
// This member is required.
TableData *types.DataCellsFilter
noSmithyDocumentSerde
}
type CreateDataCellsFilterOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDataCellsFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDataCellsFilterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDataCellsFilter(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDataCellsFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "CreateDataCellsFilter",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an LF-tag with the specified name and values.
func (c *Client) CreateLFTag(ctx context.Context, params *CreateLFTagInput, optFns ...func(*Options)) (*CreateLFTagOutput, error) {
if params == nil {
params = &CreateLFTagInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateLFTag", params, optFns, c.addOperationCreateLFTagMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateLFTagOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateLFTagInput struct {
// The key-name for the LF-tag.
//
// This member is required.
TagKey *string
// A list of possible values an attribute can take.
//
// This member is required.
TagValues []string
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type CreateLFTagOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateLFTagMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateLFTag{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateLFTag{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateLFTagValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateLFTag(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateLFTag(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "CreateLFTag",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a data cell filter.
func (c *Client) DeleteDataCellsFilter(ctx context.Context, params *DeleteDataCellsFilterInput, optFns ...func(*Options)) (*DeleteDataCellsFilterOutput, error) {
if params == nil {
params = &DeleteDataCellsFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDataCellsFilter", params, optFns, c.addOperationDeleteDataCellsFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDataCellsFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDataCellsFilterInput struct {
// A database in the Glue Data Catalog.
DatabaseName *string
// The name given by the user to the data filter cell.
Name *string
// The ID of the catalog to which the table belongs.
TableCatalogId *string
// A table in the database.
TableName *string
noSmithyDocumentSerde
}
type DeleteDataCellsFilterOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDataCellsFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDataCellsFilter(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDataCellsFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "DeleteDataCellsFilter",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified LF-tag given a key name. If the input parameter tag key
// was not found, then the operation will throw an exception. When you delete an
// LF-tag, the LFTagPolicy attached to the LF-tag becomes invalid. If the deleted
// LF-tag was still assigned to any resource, the tag policy attach to the deleted
// LF-tag will no longer be applied to the resource.
func (c *Client) DeleteLFTag(ctx context.Context, params *DeleteLFTagInput, optFns ...func(*Options)) (*DeleteLFTagOutput, error) {
if params == nil {
params = &DeleteLFTagInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteLFTag", params, optFns, c.addOperationDeleteLFTagMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteLFTagOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteLFTagInput struct {
// The key-name for the LF-tag to delete.
//
// This member is required.
TagKey *string
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type DeleteLFTagOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteLFTagMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteLFTag{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteLFTag{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteLFTagValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteLFTag(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteLFTag(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "DeleteLFTag",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// For a specific governed table, provides a list of Amazon S3 objects that will
// be written during the current transaction and that can be automatically deleted
// if the transaction is canceled. Without this call, no Amazon S3 objects are
// automatically deleted when a transaction cancels. The Glue ETL library function
// write_dynamic_frame.from_catalog() includes an option to automatically call
// DeleteObjectsOnCancel before writes. For more information, see Rolling Back
// Amazon S3 Writes (https://docs.aws.amazon.com/lake-formation/latest/dg/transactions-data-operations.html#rolling-back-writes)
// .
func (c *Client) DeleteObjectsOnCancel(ctx context.Context, params *DeleteObjectsOnCancelInput, optFns ...func(*Options)) (*DeleteObjectsOnCancelOutput, error) {
if params == nil {
params = &DeleteObjectsOnCancelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteObjectsOnCancel", params, optFns, c.addOperationDeleteObjectsOnCancelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteObjectsOnCancelOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteObjectsOnCancelInput struct {
// The database that contains the governed table.
//
// This member is required.
DatabaseName *string
// A list of VirtualObject structures, which indicates the Amazon S3 objects to be
// deleted if the transaction cancels.
//
// This member is required.
Objects []types.VirtualObject
// The name of the governed table.
//
// This member is required.
TableName *string
// ID of the transaction that the writes occur in.
//
// This member is required.
TransactionId *string
// The Glue data catalog that contains the governed table. Defaults to the current
// account ID.
CatalogId *string
noSmithyDocumentSerde
}
type DeleteObjectsOnCancelOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteObjectsOnCancelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteObjectsOnCancel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteObjectsOnCancel{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteObjectsOnCancelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteObjectsOnCancel(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteObjectsOnCancel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "DeleteObjectsOnCancel",
}
}
| 148 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deregisters the resource as managed by the Data Catalog. When you deregister a
// path, Lake Formation removes the path from the inline policy attached to your
// service-linked role.
func (c *Client) DeregisterResource(ctx context.Context, params *DeregisterResourceInput, optFns ...func(*Options)) (*DeregisterResourceOutput, error) {
if params == nil {
params = &DeregisterResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeregisterResource", params, optFns, c.addOperationDeregisterResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeregisterResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeregisterResourceInput struct {
// The Amazon Resource Name (ARN) of the resource that you want to deregister.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type DeregisterResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeregisterResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeregisterResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeregisterResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeregisterResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeregisterResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeregisterResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "DeregisterResource",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the current data access role for the given resource registered in
// Lake Formation.
func (c *Client) DescribeResource(ctx context.Context, params *DescribeResourceInput, optFns ...func(*Options)) (*DescribeResourceOutput, error) {
if params == nil {
params = &DescribeResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeResource", params, optFns, c.addOperationDescribeResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeResourceInput struct {
// The resource ARN.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type DescribeResourceOutput struct {
// A structure containing information about an Lake Formation resource.
ResourceInfo *types.ResourceInfo
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "DescribeResource",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the details of a single transaction.
func (c *Client) DescribeTransaction(ctx context.Context, params *DescribeTransactionInput, optFns ...func(*Options)) (*DescribeTransactionOutput, error) {
if params == nil {
params = &DescribeTransactionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTransaction", params, optFns, c.addOperationDescribeTransactionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTransactionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTransactionInput struct {
// The transaction for which to return status.
//
// This member is required.
TransactionId *string
noSmithyDocumentSerde
}
type DescribeTransactionOutput struct {
// Returns a TransactionDescription object containing information about the
// transaction.
TransactionDescription *types.TransactionDescription
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTransactionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTransaction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTransaction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTransactionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTransaction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTransaction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "DescribeTransaction",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Indicates to the service that the specified transaction is still active and
// should not be treated as idle and aborted. Write transactions that remain idle
// for a long period are automatically aborted unless explicitly extended.
func (c *Client) ExtendTransaction(ctx context.Context, params *ExtendTransactionInput, optFns ...func(*Options)) (*ExtendTransactionOutput, error) {
if params == nil {
params = &ExtendTransactionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ExtendTransaction", params, optFns, c.addOperationExtendTransactionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ExtendTransactionOutput)
out.ResultMetadata = metadata
return out, nil
}
type ExtendTransactionInput struct {
// The transaction to extend.
TransactionId *string
noSmithyDocumentSerde
}
type ExtendTransactionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationExtendTransactionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpExtendTransaction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpExtendTransaction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opExtendTransaction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opExtendTransaction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "ExtendTransaction",
}
}
| 117 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a data cells filter.
func (c *Client) GetDataCellsFilter(ctx context.Context, params *GetDataCellsFilterInput, optFns ...func(*Options)) (*GetDataCellsFilterOutput, error) {
if params == nil {
params = &GetDataCellsFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDataCellsFilter", params, optFns, c.addOperationGetDataCellsFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDataCellsFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDataCellsFilterInput struct {
// A database in the Glue Data Catalog.
//
// This member is required.
DatabaseName *string
// The name given by the user to the data filter cell.
//
// This member is required.
Name *string
// The ID of the catalog to which the table belongs.
//
// This member is required.
TableCatalogId *string
// A table in the database.
//
// This member is required.
TableName *string
noSmithyDocumentSerde
}
type GetDataCellsFilterOutput struct {
// A structure that describes certain columns on certain rows.
DataCellsFilter *types.DataCellsFilter
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDataCellsFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetDataCellsFilterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetDataCellsFilter(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetDataCellsFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetDataCellsFilter",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the list of the data lake administrators of a Lake Formation-managed
// data lake.
func (c *Client) GetDataLakeSettings(ctx context.Context, params *GetDataLakeSettingsInput, optFns ...func(*Options)) (*GetDataLakeSettingsOutput, error) {
if params == nil {
params = &GetDataLakeSettingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDataLakeSettings", params, optFns, c.addOperationGetDataLakeSettingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDataLakeSettingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDataLakeSettingsInput struct {
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type GetDataLakeSettingsOutput struct {
// A structure representing a list of Lake Formation principals designated as data
// lake administrators.
DataLakeSettings *types.DataLakeSettings
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDataLakeSettingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetDataLakeSettings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetDataLakeSettings{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetDataLakeSettings(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetDataLakeSettings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetDataLakeSettings",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the Lake Formation permissions for a specified table or database
// resource located at a path in Amazon S3. GetEffectivePermissionsForPath will
// not return databases and tables if the catalog is encrypted.
func (c *Client) GetEffectivePermissionsForPath(ctx context.Context, params *GetEffectivePermissionsForPathInput, optFns ...func(*Options)) (*GetEffectivePermissionsForPathOutput, error) {
if params == nil {
params = &GetEffectivePermissionsForPathInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetEffectivePermissionsForPath", params, optFns, c.addOperationGetEffectivePermissionsForPathMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetEffectivePermissionsForPathOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetEffectivePermissionsForPathInput struct {
// The Amazon Resource Name (ARN) of the resource for which you want to get
// permissions.
//
// This member is required.
ResourceArn *string
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// The maximum number of results to return.
MaxResults *int32
// A continuation token, if this is not the first call to retrieve this list.
NextToken *string
noSmithyDocumentSerde
}
type GetEffectivePermissionsForPathOutput struct {
// A continuation token, if this is not the first call to retrieve this list.
NextToken *string
// A list of the permissions for the specified table or database resource located
// at the path in Amazon S3.
Permissions []types.PrincipalResourcePermissions
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetEffectivePermissionsForPathMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetEffectivePermissionsForPath{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetEffectivePermissionsForPath{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetEffectivePermissionsForPathValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetEffectivePermissionsForPath(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// GetEffectivePermissionsForPathAPIClient is a client that implements the
// GetEffectivePermissionsForPath operation.
type GetEffectivePermissionsForPathAPIClient interface {
GetEffectivePermissionsForPath(context.Context, *GetEffectivePermissionsForPathInput, ...func(*Options)) (*GetEffectivePermissionsForPathOutput, error)
}
var _ GetEffectivePermissionsForPathAPIClient = (*Client)(nil)
// GetEffectivePermissionsForPathPaginatorOptions is the paginator options for
// GetEffectivePermissionsForPath
type GetEffectivePermissionsForPathPaginatorOptions struct {
// The maximum number of results to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// GetEffectivePermissionsForPathPaginator is a paginator for
// GetEffectivePermissionsForPath
type GetEffectivePermissionsForPathPaginator struct {
options GetEffectivePermissionsForPathPaginatorOptions
client GetEffectivePermissionsForPathAPIClient
params *GetEffectivePermissionsForPathInput
nextToken *string
firstPage bool
}
// NewGetEffectivePermissionsForPathPaginator returns a new
// GetEffectivePermissionsForPathPaginator
func NewGetEffectivePermissionsForPathPaginator(client GetEffectivePermissionsForPathAPIClient, params *GetEffectivePermissionsForPathInput, optFns ...func(*GetEffectivePermissionsForPathPaginatorOptions)) *GetEffectivePermissionsForPathPaginator {
if params == nil {
params = &GetEffectivePermissionsForPathInput{}
}
options := GetEffectivePermissionsForPathPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetEffectivePermissionsForPathPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetEffectivePermissionsForPathPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetEffectivePermissionsForPath page.
func (p *GetEffectivePermissionsForPathPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetEffectivePermissionsForPathOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.GetEffectivePermissionsForPath(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opGetEffectivePermissionsForPath(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetEffectivePermissionsForPath",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an LF-tag definition.
func (c *Client) GetLFTag(ctx context.Context, params *GetLFTagInput, optFns ...func(*Options)) (*GetLFTagOutput, error) {
if params == nil {
params = &GetLFTagInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLFTag", params, optFns, c.addOperationGetLFTagMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLFTagOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLFTagInput struct {
// The key-name for the LF-tag.
//
// This member is required.
TagKey *string
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type GetLFTagOutput struct {
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// The key-name for the LF-tag.
TagKey *string
// A list of possible values an attribute can take.
TagValues []string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLFTagMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLFTag{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLFTag{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetLFTagValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLFTag(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetLFTag(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetLFTag",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the state of a query previously submitted. Clients are expected to poll
// GetQueryState to monitor the current state of the planning before retrieving the
// work units. A query state is only visible to the principal that made the initial
// call to StartQueryPlanning .
func (c *Client) GetQueryState(ctx context.Context, params *GetQueryStateInput, optFns ...func(*Options)) (*GetQueryStateOutput, error) {
if params == nil {
params = &GetQueryStateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetQueryState", params, optFns, c.addOperationGetQueryStateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetQueryStateOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetQueryStateInput struct {
// The ID of the plan query operation.
//
// This member is required.
QueryId *string
noSmithyDocumentSerde
}
// A structure for the output.
type GetQueryStateOutput struct {
// The state of a query previously submitted. The possible states are:
// - PENDING: the query is pending.
// - WORKUNITS_AVAILABLE: some work units are ready for retrieval and execution.
// - FINISHED: the query planning finished successfully, and all work units are
// ready for retrieval and execution.
// - ERROR: an error occurred with the query, such as an invalid query ID or a
// backend error.
//
// This member is required.
State types.QueryStateString
// An error message when the operation fails.
Error *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetQueryStateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetQueryState{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetQueryState{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetQueryStateMiddleware(stack); err != nil {
return err
}
if err = addOpGetQueryStateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetQueryState(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetQueryStateMiddleware struct {
}
func (*endpointPrefix_opGetQueryStateMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetQueryStateMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "query-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetQueryStateMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetQueryStateMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetQueryState(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetQueryState",
}
}
| 171 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Retrieves statistics on the planning and execution of a query.
func (c *Client) GetQueryStatistics(ctx context.Context, params *GetQueryStatisticsInput, optFns ...func(*Options)) (*GetQueryStatisticsOutput, error) {
if params == nil {
params = &GetQueryStatisticsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetQueryStatistics", params, optFns, c.addOperationGetQueryStatisticsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetQueryStatisticsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetQueryStatisticsInput struct {
// The ID of the plan query operation.
//
// This member is required.
QueryId *string
noSmithyDocumentSerde
}
type GetQueryStatisticsOutput struct {
// An ExecutionStatistics structure containing execution statistics.
ExecutionStatistics *types.ExecutionStatistics
// A PlanningStatistics structure containing query planning statistics.
PlanningStatistics *types.PlanningStatistics
// The time that the query was submitted.
QuerySubmissionTime *time.Time
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetQueryStatisticsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetQueryStatistics{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetQueryStatistics{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetQueryStatisticsMiddleware(stack); err != nil {
return err
}
if err = addOpGetQueryStatisticsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetQueryStatistics(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetQueryStatisticsMiddleware struct {
}
func (*endpointPrefix_opGetQueryStatisticsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetQueryStatisticsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "query-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetQueryStatisticsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetQueryStatisticsMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetQueryStatistics(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetQueryStatistics",
}
}
| 163 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the LF-tags applied to a resource.
func (c *Client) GetResourceLFTags(ctx context.Context, params *GetResourceLFTagsInput, optFns ...func(*Options)) (*GetResourceLFTagsOutput, error) {
if params == nil {
params = &GetResourceLFTagsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetResourceLFTags", params, optFns, c.addOperationGetResourceLFTagsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetResourceLFTagsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetResourceLFTagsInput struct {
// The database, table, or column resource for which you want to return LF-tags.
//
// This member is required.
Resource *types.Resource
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// Indicates whether to show the assigned LF-tags.
ShowAssignedLFTags *bool
noSmithyDocumentSerde
}
type GetResourceLFTagsOutput struct {
// A list of LF-tags applied to a database resource.
LFTagOnDatabase []types.LFTagPair
// A list of LF-tags applied to a column resource.
LFTagsOnColumns []types.ColumnLFTag
// A list of LF-tags applied to a table resource.
LFTagsOnTable []types.LFTagPair
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetResourceLFTagsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetResourceLFTags{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetResourceLFTags{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetResourceLFTagsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetResourceLFTags(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetResourceLFTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetResourceLFTags",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Returns the set of Amazon S3 objects that make up the specified governed table.
// A transaction ID or timestamp can be specified for time-travel queries.
func (c *Client) GetTableObjects(ctx context.Context, params *GetTableObjectsInput, optFns ...func(*Options)) (*GetTableObjectsOutput, error) {
if params == nil {
params = &GetTableObjectsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetTableObjects", params, optFns, c.addOperationGetTableObjectsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetTableObjectsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetTableObjectsInput struct {
// The database containing the governed table.
//
// This member is required.
DatabaseName *string
// The governed table for which to retrieve objects.
//
// This member is required.
TableName *string
// The catalog containing the governed table. Defaults to the caller’s account.
CatalogId *string
// Specifies how many values to return in a page.
MaxResults *int32
// A continuation token if this is not the first call to retrieve these objects.
NextToken *string
// A predicate to filter the objects returned based on the partition keys defined
// in the governed table.
// - The comparison operators supported are: =, >, <, >=, <=
// - The logical operators supported are: AND
// - The data types supported are integer, long, date(yyyy-MM-dd),
// timestamp(yyyy-MM-dd HH:mm:ssXXX or yyyy-MM-dd HH:mm:ss"), string and decimal.
PartitionPredicate *string
// The time as of when to read the governed table contents. If not set, the most
// recent transaction commit time is used. Cannot be specified along with
// TransactionId .
QueryAsOfTime *time.Time
// The transaction ID at which to read the governed table contents. If this
// transaction has aborted, an error is returned. If not set, defaults to the most
// recent committed transaction. Cannot be specified along with QueryAsOfTime .
TransactionId *string
noSmithyDocumentSerde
}
type GetTableObjectsOutput struct {
// A continuation token indicating whether additional data is available.
NextToken *string
// A list of objects organized by partition keys.
Objects []types.PartitionObjects
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetTableObjectsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetTableObjects{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetTableObjects{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetTableObjectsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetTableObjects(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// GetTableObjectsAPIClient is a client that implements the GetTableObjects
// operation.
type GetTableObjectsAPIClient interface {
GetTableObjects(context.Context, *GetTableObjectsInput, ...func(*Options)) (*GetTableObjectsOutput, error)
}
var _ GetTableObjectsAPIClient = (*Client)(nil)
// GetTableObjectsPaginatorOptions is the paginator options for GetTableObjects
type GetTableObjectsPaginatorOptions struct {
// Specifies how many values to return in a page.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// GetTableObjectsPaginator is a paginator for GetTableObjects
type GetTableObjectsPaginator struct {
options GetTableObjectsPaginatorOptions
client GetTableObjectsAPIClient
params *GetTableObjectsInput
nextToken *string
firstPage bool
}
// NewGetTableObjectsPaginator returns a new GetTableObjectsPaginator
func NewGetTableObjectsPaginator(client GetTableObjectsAPIClient, params *GetTableObjectsInput, optFns ...func(*GetTableObjectsPaginatorOptions)) *GetTableObjectsPaginator {
if params == nil {
params = &GetTableObjectsInput{}
}
options := GetTableObjectsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetTableObjectsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetTableObjectsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetTableObjects page.
func (p *GetTableObjectsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetTableObjectsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.GetTableObjects(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opGetTableObjects(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetTableObjects",
}
}
| 253 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// This API is identical to GetTemporaryTableCredentials except that this is used
// when the target Data Catalog resource is of type Partition. Lake Formation
// restricts the permission of the vended credentials with the same scope down
// policy which restricts access to a single Amazon S3 prefix.
func (c *Client) GetTemporaryGluePartitionCredentials(ctx context.Context, params *GetTemporaryGluePartitionCredentialsInput, optFns ...func(*Options)) (*GetTemporaryGluePartitionCredentialsOutput, error) {
if params == nil {
params = &GetTemporaryGluePartitionCredentialsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetTemporaryGluePartitionCredentials", params, optFns, c.addOperationGetTemporaryGluePartitionCredentialsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetTemporaryGluePartitionCredentialsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetTemporaryGluePartitionCredentialsInput struct {
// A list of partition values identifying a single partition.
//
// This member is required.
Partition *types.PartitionValueList
// A list of supported permission types for the partition. Valid values are
// COLUMN_PERMISSION and CELL_FILTER_PERMISSION .
//
// This member is required.
SupportedPermissionTypes []types.PermissionType
// The ARN of the partitions' table.
//
// This member is required.
TableArn *string
// A structure representing context to access a resource (column names, query ID,
// etc).
AuditContext *types.AuditContext
// The time period, between 900 and 21,600 seconds, for the timeout of the
// temporary credentials.
DurationSeconds *int32
// Filters the request based on the user having been granted a list of specified
// permissions on the requested resource(s).
Permissions []types.Permission
noSmithyDocumentSerde
}
type GetTemporaryGluePartitionCredentialsOutput struct {
// The access key ID for the temporary credentials.
AccessKeyId *string
// The date and time when the temporary credentials expire.
Expiration *time.Time
// The secret key for the temporary credentials.
SecretAccessKey *string
// The session token for the temporary credentials.
SessionToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetTemporaryGluePartitionCredentialsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetTemporaryGluePartitionCredentials{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetTemporaryGluePartitionCredentials{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetTemporaryGluePartitionCredentialsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetTemporaryGluePartitionCredentials(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetTemporaryGluePartitionCredentials(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetTemporaryGluePartitionCredentials",
}
}
| 161 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Allows a caller in a secure environment to assume a role with permission to
// access Amazon S3. In order to vend such credentials, Lake Formation assumes the
// role associated with a registered location, for example an Amazon S3 bucket,
// with a scope down policy which restricts the access to a single prefix.
func (c *Client) GetTemporaryGlueTableCredentials(ctx context.Context, params *GetTemporaryGlueTableCredentialsInput, optFns ...func(*Options)) (*GetTemporaryGlueTableCredentialsOutput, error) {
if params == nil {
params = &GetTemporaryGlueTableCredentialsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetTemporaryGlueTableCredentials", params, optFns, c.addOperationGetTemporaryGlueTableCredentialsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetTemporaryGlueTableCredentialsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetTemporaryGlueTableCredentialsInput struct {
// A list of supported permission types for the table. Valid values are
// COLUMN_PERMISSION and CELL_FILTER_PERMISSION .
//
// This member is required.
SupportedPermissionTypes []types.PermissionType
// The ARN identifying a table in the Data Catalog for the temporary credentials
// request.
//
// This member is required.
TableArn *string
// A structure representing context to access a resource (column names, query ID,
// etc).
AuditContext *types.AuditContext
// The time period, between 900 and 21,600 seconds, for the timeout of the
// temporary credentials.
DurationSeconds *int32
// Filters the request based on the user having been granted a list of specified
// permissions on the requested resource(s).
Permissions []types.Permission
noSmithyDocumentSerde
}
type GetTemporaryGlueTableCredentialsOutput struct {
// The access key ID for the temporary credentials.
AccessKeyId *string
// The date and time when the temporary credentials expire.
Expiration *time.Time
// The secret key for the temporary credentials.
SecretAccessKey *string
// The session token for the temporary credentials.
SessionToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetTemporaryGlueTableCredentialsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetTemporaryGlueTableCredentials{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetTemporaryGlueTableCredentials{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetTemporaryGlueTableCredentialsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetTemporaryGlueTableCredentials(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetTemporaryGlueTableCredentials(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetTemporaryGlueTableCredentials",
}
}
| 157 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
)
// Returns the work units resulting from the query. Work units can be executed in
// any order and in parallel.
func (c *Client) GetWorkUnitResults(ctx context.Context, params *GetWorkUnitResultsInput, optFns ...func(*Options)) (*GetWorkUnitResultsOutput, error) {
if params == nil {
params = &GetWorkUnitResultsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWorkUnitResults", params, optFns, c.addOperationGetWorkUnitResultsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWorkUnitResultsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWorkUnitResultsInput struct {
// The ID of the plan query operation for which to get results.
//
// This member is required.
QueryId *string
// The work unit ID for which to get results. Value generated by enumerating
// WorkUnitIdMin to WorkUnitIdMax (inclusive) from the WorkUnitRange in the output
// of GetWorkUnits .
//
// This member is required.
WorkUnitId int64
// A work token used to query the execution service. Token output from GetWorkUnits
// .
//
// This member is required.
WorkUnitToken *string
noSmithyDocumentSerde
}
// A structure for the output.
type GetWorkUnitResultsOutput struct {
// Rows returned from the GetWorkUnitResults operation as a stream of Apache Arrow
// v1.0 messages.
ResultStream io.ReadCloser
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWorkUnitResultsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWorkUnitResults{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWorkUnitResults{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetWorkUnitResultsMiddleware(stack); err != nil {
return err
}
if err = addOpGetWorkUnitResultsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWorkUnitResults(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetWorkUnitResultsMiddleware struct {
}
func (*endpointPrefix_opGetWorkUnitResultsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetWorkUnitResultsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "data-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetWorkUnitResultsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetWorkUnitResultsMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetWorkUnitResults(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetWorkUnitResults",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the work units generated by the StartQueryPlanning operation.
func (c *Client) GetWorkUnits(ctx context.Context, params *GetWorkUnitsInput, optFns ...func(*Options)) (*GetWorkUnitsOutput, error) {
if params == nil {
params = &GetWorkUnitsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWorkUnits", params, optFns, c.addOperationGetWorkUnitsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWorkUnitsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWorkUnitsInput struct {
// The ID of the plan query operation.
//
// This member is required.
QueryId *string
// A continuation token, if this is a continuation call.
NextToken *string
// The size of each page to get in the Amazon Web Services service call. This does
// not affect the number of items returned in the command's output. Setting a
// smaller page size results in more calls to the Amazon Web Services service,
// retrieving fewer items in each call. This can help prevent the Amazon Web
// Services service calls from timing out.
PageSize *int32
noSmithyDocumentSerde
}
// A structure for the output.
type GetWorkUnitsOutput struct {
// The ID of the plan query operation.
//
// This member is required.
QueryId *string
// A WorkUnitRangeList object that specifies the valid range of work unit IDs for
// querying the execution service.
//
// This member is required.
WorkUnitRanges []types.WorkUnitRange
// A continuation token for paginating the returned list of tokens, returned if
// the current segment of the list is not the last.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWorkUnitsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWorkUnits{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWorkUnits{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetWorkUnitsMiddleware(stack); err != nil {
return err
}
if err = addOpGetWorkUnitsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWorkUnits(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetWorkUnitsMiddleware struct {
}
func (*endpointPrefix_opGetWorkUnitsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetWorkUnitsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "query-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetWorkUnitsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetWorkUnitsMiddleware{}, `OperationSerializer`, middleware.After)
}
// GetWorkUnitsAPIClient is a client that implements the GetWorkUnits operation.
type GetWorkUnitsAPIClient interface {
GetWorkUnits(context.Context, *GetWorkUnitsInput, ...func(*Options)) (*GetWorkUnitsOutput, error)
}
var _ GetWorkUnitsAPIClient = (*Client)(nil)
// GetWorkUnitsPaginatorOptions is the paginator options for GetWorkUnits
type GetWorkUnitsPaginatorOptions struct {
// The size of each page to get in the Amazon Web Services service call. This does
// not affect the number of items returned in the command's output. Setting a
// smaller page size results in more calls to the Amazon Web Services service,
// retrieving fewer items in each call. This can help prevent the Amazon Web
// Services service calls from timing out.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// GetWorkUnitsPaginator is a paginator for GetWorkUnits
type GetWorkUnitsPaginator struct {
options GetWorkUnitsPaginatorOptions
client GetWorkUnitsAPIClient
params *GetWorkUnitsInput
nextToken *string
firstPage bool
}
// NewGetWorkUnitsPaginator returns a new GetWorkUnitsPaginator
func NewGetWorkUnitsPaginator(client GetWorkUnitsAPIClient, params *GetWorkUnitsInput, optFns ...func(*GetWorkUnitsPaginatorOptions)) *GetWorkUnitsPaginator {
if params == nil {
params = &GetWorkUnitsInput{}
}
options := GetWorkUnitsPaginatorOptions{}
if params.PageSize != nil {
options.Limit = *params.PageSize
}
for _, fn := range optFns {
fn(&options)
}
return &GetWorkUnitsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetWorkUnitsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetWorkUnits page.
func (p *GetWorkUnitsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetWorkUnitsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.PageSize = limit
result, err := p.client.GetWorkUnits(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opGetWorkUnits(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GetWorkUnits",
}
}
| 272 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Grants permissions to the principal to access metadata in the Data Catalog and
// data organized in underlying data storage such as Amazon S3. For information
// about permissions, see Security and Access Control to Metadata and Data (https://docs.aws.amazon.com/lake-formation/latest/dg/security-data-access.html)
// .
func (c *Client) GrantPermissions(ctx context.Context, params *GrantPermissionsInput, optFns ...func(*Options)) (*GrantPermissionsOutput, error) {
if params == nil {
params = &GrantPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GrantPermissions", params, optFns, c.addOperationGrantPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GrantPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GrantPermissionsInput struct {
// The permissions granted to the principal on the resource. Lake Formation
// defines privileges to grant and revoke access to metadata in the Data Catalog
// and data organized in underlying data storage such as Amazon S3. Lake Formation
// requires that each principal be authorized to perform a specific task on Lake
// Formation resources.
//
// This member is required.
Permissions []types.Permission
// The principal to be granted the permissions on the resource. Supported
// principals are IAM users or IAM roles, and they are defined by their principal
// type and their ARN. Note that if you define a resource with a particular ARN,
// then later delete, and recreate a resource with that same ARN, the resource
// maintains the permissions already granted.
//
// This member is required.
Principal *types.DataLakePrincipal
// The resource to which permissions are to be granted. Resources in Lake
// Formation are the Data Catalog, databases, and tables.
//
// This member is required.
Resource *types.Resource
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// Indicates a list of the granted permissions that the principal may pass to
// other users. These permissions may only be a subset of the permissions granted
// in the Privileges .
PermissionsWithGrantOption []types.Permission
noSmithyDocumentSerde
}
type GrantPermissionsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGrantPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGrantPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGrantPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGrantPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGrantPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGrantPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "GrantPermissions",
}
}
| 154 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all the data cell filters on a table.
func (c *Client) ListDataCellsFilter(ctx context.Context, params *ListDataCellsFilterInput, optFns ...func(*Options)) (*ListDataCellsFilterOutput, error) {
if params == nil {
params = &ListDataCellsFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDataCellsFilter", params, optFns, c.addOperationListDataCellsFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDataCellsFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDataCellsFilterInput struct {
// The maximum size of the response.
MaxResults *int32
// A continuation token, if this is a continuation call.
NextToken *string
// A table in the Glue Data Catalog.
Table *types.TableResource
noSmithyDocumentSerde
}
type ListDataCellsFilterOutput struct {
// A list of DataCellFilter structures.
DataCellsFilters []types.DataCellsFilter
// A continuation token, if not all requested data cell filters have been returned.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDataCellsFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListDataCellsFilterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDataCellsFilter(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDataCellsFilterAPIClient is a client that implements the
// ListDataCellsFilter operation.
type ListDataCellsFilterAPIClient interface {
ListDataCellsFilter(context.Context, *ListDataCellsFilterInput, ...func(*Options)) (*ListDataCellsFilterOutput, error)
}
var _ ListDataCellsFilterAPIClient = (*Client)(nil)
// ListDataCellsFilterPaginatorOptions is the paginator options for
// ListDataCellsFilter
type ListDataCellsFilterPaginatorOptions struct {
// The maximum size of the response.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListDataCellsFilterPaginator is a paginator for ListDataCellsFilter
type ListDataCellsFilterPaginator struct {
options ListDataCellsFilterPaginatorOptions
client ListDataCellsFilterAPIClient
params *ListDataCellsFilterInput
nextToken *string
firstPage bool
}
// NewListDataCellsFilterPaginator returns a new ListDataCellsFilterPaginator
func NewListDataCellsFilterPaginator(client ListDataCellsFilterAPIClient, params *ListDataCellsFilterInput, optFns ...func(*ListDataCellsFilterPaginatorOptions)) *ListDataCellsFilterPaginator {
if params == nil {
params = &ListDataCellsFilterInput{}
}
options := ListDataCellsFilterPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDataCellsFilterPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDataCellsFilterPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDataCellsFilter page.
func (p *ListDataCellsFilterPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDataCellsFilterOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDataCellsFilter(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDataCellsFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "ListDataCellsFilter",
}
}
| 224 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists LF-tags that the requester has permission to view.
func (c *Client) ListLFTags(ctx context.Context, params *ListLFTagsInput, optFns ...func(*Options)) (*ListLFTagsOutput, error) {
if params == nil {
params = &ListLFTagsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListLFTags", params, optFns, c.addOperationListLFTagsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListLFTagsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListLFTagsInput struct {
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// The maximum number of results to return.
MaxResults *int32
// A continuation token, if this is not the first call to retrieve this list.
NextToken *string
// If resource share type is ALL , returns both in-account LF-tags and shared
// LF-tags that the requester has permission to view. If resource share type is
// FOREIGN , returns all share LF-tags that the requester can view. If no resource
// share type is passed, lists LF-tags in the given catalog ID that the requester
// has permission to view.
ResourceShareType types.ResourceShareType
noSmithyDocumentSerde
}
type ListLFTagsOutput struct {
// A list of LF-tags that the requested has permission to view.
LFTags []types.LFTagPair
// A continuation token, present if the current list segment is not the last.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListLFTagsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListLFTags{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListLFTags{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListLFTags(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListLFTagsAPIClient is a client that implements the ListLFTags operation.
type ListLFTagsAPIClient interface {
ListLFTags(context.Context, *ListLFTagsInput, ...func(*Options)) (*ListLFTagsOutput, error)
}
var _ ListLFTagsAPIClient = (*Client)(nil)
// ListLFTagsPaginatorOptions is the paginator options for ListLFTags
type ListLFTagsPaginatorOptions struct {
// The maximum number of results to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListLFTagsPaginator is a paginator for ListLFTags
type ListLFTagsPaginator struct {
options ListLFTagsPaginatorOptions
client ListLFTagsAPIClient
params *ListLFTagsInput
nextToken *string
firstPage bool
}
// NewListLFTagsPaginator returns a new ListLFTagsPaginator
func NewListLFTagsPaginator(client ListLFTagsAPIClient, params *ListLFTagsInput, optFns ...func(*ListLFTagsPaginatorOptions)) *ListLFTagsPaginator {
if params == nil {
params = &ListLFTagsInput{}
}
options := ListLFTagsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListLFTagsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListLFTagsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListLFTags page.
func (p *ListLFTagsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListLFTagsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListLFTags(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListLFTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "ListLFTags",
}
}
| 229 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of the principal permissions on the resource, filtered by the
// permissions of the caller. For example, if you are granted an ALTER permission,
// you are able to see only the principal permissions for ALTER. This operation
// returns only those permissions that have been explicitly granted. For
// information about permissions, see Security and Access Control to Metadata and
// Data (https://docs-aws.amazon.com/lake-formation/latest/dg/security-data-access.html)
// .
func (c *Client) ListPermissions(ctx context.Context, params *ListPermissionsInput, optFns ...func(*Options)) (*ListPermissionsOutput, error) {
if params == nil {
params = &ListPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListPermissions", params, optFns, c.addOperationListPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListPermissionsInput struct {
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// Indicates that related permissions should be included in the results.
IncludeRelated *string
// The maximum number of results to return.
MaxResults *int32
// A continuation token, if this is not the first call to retrieve this list.
NextToken *string
// Specifies a principal to filter the permissions returned.
Principal *types.DataLakePrincipal
// A resource where you will get a list of the principal permissions. This
// operation does not support getting privileges on a table with columns. Instead,
// call this operation on the table, and the operation returns the table and the
// table w columns.
Resource *types.Resource
// Specifies a resource type to filter the permissions returned.
ResourceType types.DataLakeResourceType
noSmithyDocumentSerde
}
type ListPermissionsOutput struct {
// A continuation token, if this is not the first call to retrieve this list.
NextToken *string
// A list of principals and their permissions on the resource for the specified
// principal and resource types.
PrincipalResourcePermissions []types.PrincipalResourcePermissions
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListPermissionsAPIClient is a client that implements the ListPermissions
// operation.
type ListPermissionsAPIClient interface {
ListPermissions(context.Context, *ListPermissionsInput, ...func(*Options)) (*ListPermissionsOutput, error)
}
var _ ListPermissionsAPIClient = (*Client)(nil)
// ListPermissionsPaginatorOptions is the paginator options for ListPermissions
type ListPermissionsPaginatorOptions struct {
// The maximum number of results to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListPermissionsPaginator is a paginator for ListPermissions
type ListPermissionsPaginator struct {
options ListPermissionsPaginatorOptions
client ListPermissionsAPIClient
params *ListPermissionsInput
nextToken *string
firstPage bool
}
// NewListPermissionsPaginator returns a new ListPermissionsPaginator
func NewListPermissionsPaginator(client ListPermissionsAPIClient, params *ListPermissionsInput, optFns ...func(*ListPermissionsPaginatorOptions)) *ListPermissionsPaginator {
if params == nil {
params = &ListPermissionsInput{}
}
options := ListPermissionsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListPermissionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListPermissionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListPermissions page.
func (p *ListPermissionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPermissionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListPermissions(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "ListPermissions",
}
}
| 248 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the resources registered to be managed by the Data Catalog.
func (c *Client) ListResources(ctx context.Context, params *ListResourcesInput, optFns ...func(*Options)) (*ListResourcesOutput, error) {
if params == nil {
params = &ListResourcesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListResources", params, optFns, c.addOperationListResourcesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListResourcesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListResourcesInput struct {
// Any applicable row-level and/or column-level filtering conditions for the
// resources.
FilterConditionList []types.FilterCondition
// The maximum number of resource results.
MaxResults *int32
// A continuation token, if this is not the first call to retrieve these resources.
NextToken *string
noSmithyDocumentSerde
}
type ListResourcesOutput struct {
// A continuation token, if this is not the first call to retrieve these resources.
NextToken *string
// A summary of the data lake resources.
ResourceInfoList []types.ResourceInfo
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListResourcesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListResources{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListResources{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListResources(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListResourcesAPIClient is a client that implements the ListResources operation.
type ListResourcesAPIClient interface {
ListResources(context.Context, *ListResourcesInput, ...func(*Options)) (*ListResourcesOutput, error)
}
var _ ListResourcesAPIClient = (*Client)(nil)
// ListResourcesPaginatorOptions is the paginator options for ListResources
type ListResourcesPaginatorOptions struct {
// The maximum number of resource results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListResourcesPaginator is a paginator for ListResources
type ListResourcesPaginator struct {
options ListResourcesPaginatorOptions
client ListResourcesAPIClient
params *ListResourcesInput
nextToken *string
firstPage bool
}
// NewListResourcesPaginator returns a new ListResourcesPaginator
func NewListResourcesPaginator(client ListResourcesAPIClient, params *ListResourcesInput, optFns ...func(*ListResourcesPaginatorOptions)) *ListResourcesPaginator {
if params == nil {
params = &ListResourcesInput{}
}
options := ListResourcesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListResourcesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListResourcesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListResources page.
func (p *ListResourcesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListResourcesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListResources(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListResources(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "ListResources",
}
}
| 220 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the configuration of all storage optimizers associated with a specified
// table.
func (c *Client) ListTableStorageOptimizers(ctx context.Context, params *ListTableStorageOptimizersInput, optFns ...func(*Options)) (*ListTableStorageOptimizersOutput, error) {
if params == nil {
params = &ListTableStorageOptimizersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTableStorageOptimizers", params, optFns, c.addOperationListTableStorageOptimizersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTableStorageOptimizersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTableStorageOptimizersInput struct {
// Name of the database where the table is present.
//
// This member is required.
DatabaseName *string
// Name of the table.
//
// This member is required.
TableName *string
// The Catalog ID of the table.
CatalogId *string
// The number of storage optimizers to return on each call.
MaxResults *int32
// A continuation token, if this is a continuation call.
NextToken *string
// The specific type of storage optimizers to list. The supported value is
// compaction .
StorageOptimizerType types.OptimizerType
noSmithyDocumentSerde
}
type ListTableStorageOptimizersOutput struct {
// A continuation token for paginating the returned list of tokens, returned if
// the current segment of the list is not the last.
NextToken *string
// A list of the storage optimizers associated with a table.
StorageOptimizerList []types.StorageOptimizer
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTableStorageOptimizersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListTableStorageOptimizers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListTableStorageOptimizers{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListTableStorageOptimizersValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTableStorageOptimizers(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListTableStorageOptimizersAPIClient is a client that implements the
// ListTableStorageOptimizers operation.
type ListTableStorageOptimizersAPIClient interface {
ListTableStorageOptimizers(context.Context, *ListTableStorageOptimizersInput, ...func(*Options)) (*ListTableStorageOptimizersOutput, error)
}
var _ ListTableStorageOptimizersAPIClient = (*Client)(nil)
// ListTableStorageOptimizersPaginatorOptions is the paginator options for
// ListTableStorageOptimizers
type ListTableStorageOptimizersPaginatorOptions struct {
// The number of storage optimizers to return on each call.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListTableStorageOptimizersPaginator is a paginator for
// ListTableStorageOptimizers
type ListTableStorageOptimizersPaginator struct {
options ListTableStorageOptimizersPaginatorOptions
client ListTableStorageOptimizersAPIClient
params *ListTableStorageOptimizersInput
nextToken *string
firstPage bool
}
// NewListTableStorageOptimizersPaginator returns a new
// ListTableStorageOptimizersPaginator
func NewListTableStorageOptimizersPaginator(client ListTableStorageOptimizersAPIClient, params *ListTableStorageOptimizersInput, optFns ...func(*ListTableStorageOptimizersPaginatorOptions)) *ListTableStorageOptimizersPaginator {
if params == nil {
params = &ListTableStorageOptimizersInput{}
}
options := ListTableStorageOptimizersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListTableStorageOptimizersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListTableStorageOptimizersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListTableStorageOptimizers page.
func (p *ListTableStorageOptimizersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListTableStorageOptimizersOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListTableStorageOptimizers(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListTableStorageOptimizers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "ListTableStorageOptimizers",
}
}
| 242 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns metadata about transactions and their status. To prevent the response
// from growing indefinitely, only uncommitted transactions and those available for
// time-travel queries are returned. This operation can help you identify
// uncommitted transactions or to get information about transactions.
func (c *Client) ListTransactions(ctx context.Context, params *ListTransactionsInput, optFns ...func(*Options)) (*ListTransactionsOutput, error) {
if params == nil {
params = &ListTransactionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTransactions", params, optFns, c.addOperationListTransactionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTransactionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTransactionsInput struct {
// The catalog for which to list transactions. Defaults to the account ID of the
// caller.
CatalogId *string
// The maximum number of transactions to return in a single call.
MaxResults *int32
// A continuation token if this is not the first call to retrieve transactions.
NextToken *string
// A filter indicating the status of transactions to return. Options are ALL |
// COMPLETED | COMMITTED | ABORTED | ACTIVE. The default is ALL .
StatusFilter types.TransactionStatusFilter
noSmithyDocumentSerde
}
type ListTransactionsOutput struct {
// A continuation token indicating whether additional data is available.
NextToken *string
// A list of transactions. The record for each transaction is a
// TransactionDescription object.
Transactions []types.TransactionDescription
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTransactionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListTransactions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListTransactions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTransactions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListTransactionsAPIClient is a client that implements the ListTransactions
// operation.
type ListTransactionsAPIClient interface {
ListTransactions(context.Context, *ListTransactionsInput, ...func(*Options)) (*ListTransactionsOutput, error)
}
var _ ListTransactionsAPIClient = (*Client)(nil)
// ListTransactionsPaginatorOptions is the paginator options for ListTransactions
type ListTransactionsPaginatorOptions struct {
// The maximum number of transactions to return in a single call.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListTransactionsPaginator is a paginator for ListTransactions
type ListTransactionsPaginator struct {
options ListTransactionsPaginatorOptions
client ListTransactionsAPIClient
params *ListTransactionsInput
nextToken *string
firstPage bool
}
// NewListTransactionsPaginator returns a new ListTransactionsPaginator
func NewListTransactionsPaginator(client ListTransactionsAPIClient, params *ListTransactionsInput, optFns ...func(*ListTransactionsPaginatorOptions)) *ListTransactionsPaginator {
if params == nil {
params = &ListTransactionsInput{}
}
options := ListTransactionsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListTransactionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListTransactionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListTransactions page.
func (p *ListTransactionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListTransactionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListTransactions(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListTransactions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "ListTransactions",
}
}
| 229 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Sets the list of data lake administrators who have admin privileges on all
// resources managed by Lake Formation. For more information on admin privileges,
// see Granting Lake Formation Permissions (https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html)
// . This API replaces the current list of data lake admins with the new list being
// passed. To add an admin, fetch the current list and add the new admin to that
// list and pass that list in this API.
func (c *Client) PutDataLakeSettings(ctx context.Context, params *PutDataLakeSettingsInput, optFns ...func(*Options)) (*PutDataLakeSettingsOutput, error) {
if params == nil {
params = &PutDataLakeSettingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutDataLakeSettings", params, optFns, c.addOperationPutDataLakeSettingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutDataLakeSettingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutDataLakeSettingsInput struct {
// A structure representing a list of Lake Formation principals designated as data
// lake administrators.
//
// This member is required.
DataLakeSettings *types.DataLakeSettings
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type PutDataLakeSettingsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutDataLakeSettingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpPutDataLakeSettings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpPutDataLakeSettings{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpPutDataLakeSettingsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutDataLakeSettings(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opPutDataLakeSettings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "PutDataLakeSettings",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Registers the resource as managed by the Data Catalog. To add or update data,
// Lake Formation needs read/write access to the chosen Amazon S3 path. Choose a
// role that you know has permission to do this, or choose the
// AWSServiceRoleForLakeFormationDataAccess service-linked role. When you register
// the first Amazon S3 path, the service-linked role and a new inline policy are
// created on your behalf. Lake Formation adds the first path to the inline policy
// and attaches it to the service-linked role. When you register subsequent paths,
// Lake Formation adds the path to the existing policy. The following request
// registers a new location and gives Lake Formation permission to use the
// service-linked role to access that location. ResourceArn =
// arn:aws:s3:::my-bucket UseServiceLinkedRole = true If UseServiceLinkedRole is
// not set to true, you must provide or set the RoleArn :
// arn:aws:iam::12345:role/my-data-access-role
func (c *Client) RegisterResource(ctx context.Context, params *RegisterResourceInput, optFns ...func(*Options)) (*RegisterResourceOutput, error) {
if params == nil {
params = &RegisterResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RegisterResource", params, optFns, c.addOperationRegisterResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RegisterResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type RegisterResourceInput struct {
// The Amazon Resource Name (ARN) of the resource that you want to register.
//
// This member is required.
ResourceArn *string
// The identifier for the role that registers the resource.
RoleArn *string
// Designates an Identity and Access Management (IAM) service-linked role by
// registering this role with the Data Catalog. A service-linked role is a unique
// type of IAM role that is linked directly to Lake Formation. For more
// information, see Using Service-Linked Roles for Lake Formation (https://docs.aws.amazon.com/lake-formation/latest/dg/service-linked-roles.html)
// .
UseServiceLinkedRole *bool
// Whether or not the resource is a federated resource.
WithFederation *bool
noSmithyDocumentSerde
}
type RegisterResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRegisterResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpRegisterResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpRegisterResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpRegisterResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRegisterResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opRegisterResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "RegisterResource",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes an LF-tag from the resource. Only database, table, or tableWithColumns
// resource are allowed. To tag columns, use the column inclusion list in
// tableWithColumns to specify column input.
func (c *Client) RemoveLFTagsFromResource(ctx context.Context, params *RemoveLFTagsFromResourceInput, optFns ...func(*Options)) (*RemoveLFTagsFromResourceOutput, error) {
if params == nil {
params = &RemoveLFTagsFromResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RemoveLFTagsFromResource", params, optFns, c.addOperationRemoveLFTagsFromResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RemoveLFTagsFromResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type RemoveLFTagsFromResourceInput struct {
// The LF-tags to be removed from the resource.
//
// This member is required.
LFTags []types.LFTagPair
// The database, table, or column resource where you want to remove an LF-tag.
//
// This member is required.
Resource *types.Resource
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
type RemoveLFTagsFromResourceOutput struct {
// A list of failures to untag a resource.
Failures []types.LFTagError
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRemoveLFTagsFromResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpRemoveLFTagsFromResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpRemoveLFTagsFromResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpRemoveLFTagsFromResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRemoveLFTagsFromResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opRemoveLFTagsFromResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "RemoveLFTagsFromResource",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Revokes permissions to the principal to access metadata in the Data Catalog and
// data organized in underlying data storage such as Amazon S3.
func (c *Client) RevokePermissions(ctx context.Context, params *RevokePermissionsInput, optFns ...func(*Options)) (*RevokePermissionsOutput, error) {
if params == nil {
params = &RevokePermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RevokePermissions", params, optFns, c.addOperationRevokePermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RevokePermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type RevokePermissionsInput struct {
// The permissions revoked to the principal on the resource. For information about
// permissions, see Security and Access Control to Metadata and Data (https://docs.aws.amazon.com/lake-formation/latest/dg/security-data-access.html)
// .
//
// This member is required.
Permissions []types.Permission
// The principal to be revoked permissions on the resource.
//
// This member is required.
Principal *types.DataLakePrincipal
// The resource to which permissions are to be revoked.
//
// This member is required.
Resource *types.Resource
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// Indicates a list of permissions for which to revoke the grant option allowing
// the principal to pass permissions to other principals.
PermissionsWithGrantOption []types.Permission
noSmithyDocumentSerde
}
type RevokePermissionsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRevokePermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpRevokePermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpRevokePermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpRevokePermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRevokePermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opRevokePermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "RevokePermissions",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation allows a search on DATABASE resources by TagCondition . This
// operation is used by admins who want to grant user permissions on certain
// TagConditions . Before making a grant, the admin can use SearchDatabasesByTags
// to find all resources where the given TagConditions are valid to verify whether
// the returned resources can be shared.
func (c *Client) SearchDatabasesByLFTags(ctx context.Context, params *SearchDatabasesByLFTagsInput, optFns ...func(*Options)) (*SearchDatabasesByLFTagsOutput, error) {
if params == nil {
params = &SearchDatabasesByLFTagsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SearchDatabasesByLFTags", params, optFns, c.addOperationSearchDatabasesByLFTagsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SearchDatabasesByLFTagsOutput)
out.ResultMetadata = metadata
return out, nil
}
type SearchDatabasesByLFTagsInput struct {
// A list of conditions ( LFTag structures) to search for in database resources.
//
// This member is required.
Expression []types.LFTag
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// The maximum number of results to return.
MaxResults *int32
// A continuation token, if this is not the first call to retrieve this list.
NextToken *string
noSmithyDocumentSerde
}
type SearchDatabasesByLFTagsOutput struct {
// A list of databases that meet the LF-tag conditions.
DatabaseList []types.TaggedDatabase
// A continuation token, present if the current list segment is not the last.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSearchDatabasesByLFTagsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpSearchDatabasesByLFTags{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpSearchDatabasesByLFTags{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpSearchDatabasesByLFTagsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSearchDatabasesByLFTags(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// SearchDatabasesByLFTagsAPIClient is a client that implements the
// SearchDatabasesByLFTags operation.
type SearchDatabasesByLFTagsAPIClient interface {
SearchDatabasesByLFTags(context.Context, *SearchDatabasesByLFTagsInput, ...func(*Options)) (*SearchDatabasesByLFTagsOutput, error)
}
var _ SearchDatabasesByLFTagsAPIClient = (*Client)(nil)
// SearchDatabasesByLFTagsPaginatorOptions is the paginator options for
// SearchDatabasesByLFTags
type SearchDatabasesByLFTagsPaginatorOptions struct {
// The maximum number of results to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// SearchDatabasesByLFTagsPaginator is a paginator for SearchDatabasesByLFTags
type SearchDatabasesByLFTagsPaginator struct {
options SearchDatabasesByLFTagsPaginatorOptions
client SearchDatabasesByLFTagsAPIClient
params *SearchDatabasesByLFTagsInput
nextToken *string
firstPage bool
}
// NewSearchDatabasesByLFTagsPaginator returns a new
// SearchDatabasesByLFTagsPaginator
func NewSearchDatabasesByLFTagsPaginator(client SearchDatabasesByLFTagsAPIClient, params *SearchDatabasesByLFTagsInput, optFns ...func(*SearchDatabasesByLFTagsPaginatorOptions)) *SearchDatabasesByLFTagsPaginator {
if params == nil {
params = &SearchDatabasesByLFTagsInput{}
}
options := SearchDatabasesByLFTagsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &SearchDatabasesByLFTagsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *SearchDatabasesByLFTagsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next SearchDatabasesByLFTags page.
func (p *SearchDatabasesByLFTagsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*SearchDatabasesByLFTagsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.SearchDatabasesByLFTags(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opSearchDatabasesByLFTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "SearchDatabasesByLFTags",
}
}
| 237 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation allows a search on TABLE resources by LFTag s. This will be used
// by admins who want to grant user permissions on certain LF-tags. Before making a
// grant, the admin can use SearchTablesByLFTags to find all resources where the
// given LFTag s are valid to verify whether the returned resources can be shared.
func (c *Client) SearchTablesByLFTags(ctx context.Context, params *SearchTablesByLFTagsInput, optFns ...func(*Options)) (*SearchTablesByLFTagsOutput, error) {
if params == nil {
params = &SearchTablesByLFTagsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SearchTablesByLFTags", params, optFns, c.addOperationSearchTablesByLFTagsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SearchTablesByLFTagsOutput)
out.ResultMetadata = metadata
return out, nil
}
type SearchTablesByLFTagsInput struct {
// A list of conditions ( LFTag structures) to search for in table resources.
//
// This member is required.
Expression []types.LFTag
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// The maximum number of results to return.
MaxResults *int32
// A continuation token, if this is not the first call to retrieve this list.
NextToken *string
noSmithyDocumentSerde
}
type SearchTablesByLFTagsOutput struct {
// A continuation token, present if the current list segment is not the last.
NextToken *string
// A list of tables that meet the LF-tag conditions.
TableList []types.TaggedTable
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSearchTablesByLFTagsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpSearchTablesByLFTags{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpSearchTablesByLFTags{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpSearchTablesByLFTagsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSearchTablesByLFTags(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// SearchTablesByLFTagsAPIClient is a client that implements the
// SearchTablesByLFTags operation.
type SearchTablesByLFTagsAPIClient interface {
SearchTablesByLFTags(context.Context, *SearchTablesByLFTagsInput, ...func(*Options)) (*SearchTablesByLFTagsOutput, error)
}
var _ SearchTablesByLFTagsAPIClient = (*Client)(nil)
// SearchTablesByLFTagsPaginatorOptions is the paginator options for
// SearchTablesByLFTags
type SearchTablesByLFTagsPaginatorOptions struct {
// The maximum number of results to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// SearchTablesByLFTagsPaginator is a paginator for SearchTablesByLFTags
type SearchTablesByLFTagsPaginator struct {
options SearchTablesByLFTagsPaginatorOptions
client SearchTablesByLFTagsAPIClient
params *SearchTablesByLFTagsInput
nextToken *string
firstPage bool
}
// NewSearchTablesByLFTagsPaginator returns a new SearchTablesByLFTagsPaginator
func NewSearchTablesByLFTagsPaginator(client SearchTablesByLFTagsAPIClient, params *SearchTablesByLFTagsInput, optFns ...func(*SearchTablesByLFTagsPaginatorOptions)) *SearchTablesByLFTagsPaginator {
if params == nil {
params = &SearchTablesByLFTagsInput{}
}
options := SearchTablesByLFTagsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &SearchTablesByLFTagsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *SearchTablesByLFTagsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next SearchTablesByLFTags page.
func (p *SearchTablesByLFTagsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*SearchTablesByLFTagsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.SearchTablesByLFTags(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opSearchTablesByLFTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "SearchTablesByLFTags",
}
}
| 235 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Submits a request to process a query statement. This operation generates work
// units that can be retrieved with the GetWorkUnits operation as soon as the
// query state is WORKUNITS_AVAILABLE or FINISHED.
func (c *Client) StartQueryPlanning(ctx context.Context, params *StartQueryPlanningInput, optFns ...func(*Options)) (*StartQueryPlanningOutput, error) {
if params == nil {
params = &StartQueryPlanningInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartQueryPlanning", params, optFns, c.addOperationStartQueryPlanningMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartQueryPlanningOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartQueryPlanningInput struct {
// A structure containing information about the query plan.
//
// This member is required.
QueryPlanningContext *types.QueryPlanningContext
// A PartiQL query statement used as an input to the planner service.
//
// This member is required.
QueryString *string
noSmithyDocumentSerde
}
// A structure for the output.
type StartQueryPlanningOutput struct {
// The ID of the plan query operation can be used to fetch the actual work unit
// descriptors that are produced as the result of the operation. The ID is also
// used to get the query state and as an input to the Execute operation.
//
// This member is required.
QueryId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartQueryPlanningMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartQueryPlanning{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartQueryPlanning{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opStartQueryPlanningMiddleware(stack); err != nil {
return err
}
if err = addOpStartQueryPlanningValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartQueryPlanning(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opStartQueryPlanningMiddleware struct {
}
func (*endpointPrefix_opStartQueryPlanningMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opStartQueryPlanningMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "query-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opStartQueryPlanningMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opStartQueryPlanningMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opStartQueryPlanning(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "StartQueryPlanning",
}
}
| 168 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a new transaction and returns its transaction ID. Transaction IDs are
// opaque objects that you can use to identify a transaction.
func (c *Client) StartTransaction(ctx context.Context, params *StartTransactionInput, optFns ...func(*Options)) (*StartTransactionOutput, error) {
if params == nil {
params = &StartTransactionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartTransaction", params, optFns, c.addOperationStartTransactionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartTransactionOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartTransactionInput struct {
// Indicates whether this transaction should be read only or read and write.
// Writes made using a read-only transaction ID will be rejected. Read-only
// transactions do not need to be committed.
TransactionType types.TransactionType
noSmithyDocumentSerde
}
type StartTransactionOutput struct {
// An opaque identifier for the transaction.
TransactionId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartTransactionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartTransaction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartTransaction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartTransaction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opStartTransaction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "StartTransaction",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates a data cell filter.
func (c *Client) UpdateDataCellsFilter(ctx context.Context, params *UpdateDataCellsFilterInput, optFns ...func(*Options)) (*UpdateDataCellsFilterOutput, error) {
if params == nil {
params = &UpdateDataCellsFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateDataCellsFilter", params, optFns, c.addOperationUpdateDataCellsFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateDataCellsFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateDataCellsFilterInput struct {
// A DataCellsFilter structure containing information about the data cells filter.
//
// This member is required.
TableData *types.DataCellsFilter
noSmithyDocumentSerde
}
type UpdateDataCellsFilterOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateDataCellsFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateDataCellsFilter{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateDataCellsFilterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateDataCellsFilter(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUpdateDataCellsFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "UpdateDataCellsFilter",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the list of possible values for the specified LF-tag key. If the LF-tag
// does not exist, the operation throws an EntityNotFoundException. The values in
// the delete key values will be deleted from list of possible values. If any value
// in the delete key values is attached to a resource, then API errors out with a
// 400 Exception - "Update not allowed". Untag the attribute before deleting the
// LF-tag key's value.
func (c *Client) UpdateLFTag(ctx context.Context, params *UpdateLFTagInput, optFns ...func(*Options)) (*UpdateLFTagOutput, error) {
if params == nil {
params = &UpdateLFTagInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateLFTag", params, optFns, c.addOperationUpdateLFTagMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateLFTagOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateLFTagInput struct {
// The key-name for the LF-tag for which to add or delete values.
//
// This member is required.
TagKey *string
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
// A list of LF-tag values to add from the LF-tag.
TagValuesToAdd []string
// A list of LF-tag values to delete from the LF-tag.
TagValuesToDelete []string
noSmithyDocumentSerde
}
type UpdateLFTagOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateLFTagMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateLFTag{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateLFTag{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateLFTagValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateLFTag(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUpdateLFTag(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "UpdateLFTag",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the data access role used for vending access to the given (registered)
// resource in Lake Formation.
func (c *Client) UpdateResource(ctx context.Context, params *UpdateResourceInput, optFns ...func(*Options)) (*UpdateResourceOutput, error) {
if params == nil {
params = &UpdateResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateResource", params, optFns, c.addOperationUpdateResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateResourceInput struct {
// The resource ARN.
//
// This member is required.
ResourceArn *string
// The new role to use for the given resource registered in Lake Formation.
//
// This member is required.
RoleArn *string
// Whether or not the resource is a federated resource.
WithFederation *bool
noSmithyDocumentSerde
}
type UpdateResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUpdateResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "UpdateResource",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the manifest of Amazon S3 objects that make up the specified governed
// table.
func (c *Client) UpdateTableObjects(ctx context.Context, params *UpdateTableObjectsInput, optFns ...func(*Options)) (*UpdateTableObjectsOutput, error) {
if params == nil {
params = &UpdateTableObjectsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateTableObjects", params, optFns, c.addOperationUpdateTableObjectsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateTableObjectsOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateTableObjectsInput struct {
// The database containing the governed table to update.
//
// This member is required.
DatabaseName *string
// The governed table to update.
//
// This member is required.
TableName *string
// A list of WriteOperation objects that define an object to add to or delete from
// the manifest for a governed table.
//
// This member is required.
WriteOperations []types.WriteOperation
// The catalog containing the governed table to update. Defaults to the caller’s
// account ID.
CatalogId *string
// The transaction at which to do the write.
TransactionId *string
noSmithyDocumentSerde
}
type UpdateTableObjectsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateTableObjectsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateTableObjects{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateTableObjects{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateTableObjectsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateTableObjects(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUpdateTableObjects(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "UpdateTableObjects",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the configuration of the storage optimizers for a table.
func (c *Client) UpdateTableStorageOptimizer(ctx context.Context, params *UpdateTableStorageOptimizerInput, optFns ...func(*Options)) (*UpdateTableStorageOptimizerOutput, error) {
if params == nil {
params = &UpdateTableStorageOptimizerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateTableStorageOptimizer", params, optFns, c.addOperationUpdateTableStorageOptimizerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateTableStorageOptimizerOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateTableStorageOptimizerInput struct {
// Name of the database where the table is present.
//
// This member is required.
DatabaseName *string
// Name of the table for which to enable the storage optimizer.
//
// This member is required.
StorageOptimizerConfig map[string]map[string]string
// Name of the table for which to enable the storage optimizer.
//
// This member is required.
TableName *string
// The Catalog ID of the table.
CatalogId *string
noSmithyDocumentSerde
}
type UpdateTableStorageOptimizerOutput struct {
// A response indicating the success of failure of the operation.
Result *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateTableStorageOptimizerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateTableStorageOptimizer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateTableStorageOptimizer{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateTableStorageOptimizerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateTableStorageOptimizer(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUpdateTableStorageOptimizer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lakeformation",
OperationName: "UpdateTableStorageOptimizer",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"strings"
)
type awsRestjson1_deserializeOpAddLFTagsToResource struct {
}
func (*awsRestjson1_deserializeOpAddLFTagsToResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpAddLFTagsToResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorAddLFTagsToResource(response, &metadata)
}
output := &AddLFTagsToResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentAddLFTagsToResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorAddLFTagsToResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentAddLFTagsToResourceOutput(v **AddLFTagsToResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *AddLFTagsToResourceOutput
if *v == nil {
sv = &AddLFTagsToResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Failures":
if err := awsRestjson1_deserializeDocumentLFTagErrors(&sv.Failures, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpAssumeDecoratedRoleWithSAML struct {
}
func (*awsRestjson1_deserializeOpAssumeDecoratedRoleWithSAML) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpAssumeDecoratedRoleWithSAML) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorAssumeDecoratedRoleWithSAML(response, &metadata)
}
output := &AssumeDecoratedRoleWithSAMLOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentAssumeDecoratedRoleWithSAMLOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorAssumeDecoratedRoleWithSAML(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentAssumeDecoratedRoleWithSAMLOutput(v **AssumeDecoratedRoleWithSAMLOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *AssumeDecoratedRoleWithSAMLOutput
if *v == nil {
sv = &AssumeDecoratedRoleWithSAMLOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccessKeyIdString to be of type string, got %T instead", value)
}
sv.AccessKeyId = ptr.String(jtv)
}
case "Expiration":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Expiration = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected ExpirationTimestamp to be a JSON Number, got %T instead", value)
}
}
case "SecretAccessKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SecretAccessKeyString to be of type string, got %T instead", value)
}
sv.SecretAccessKey = ptr.String(jtv)
}
case "SessionToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SessionTokenString to be of type string, got %T instead", value)
}
sv.SessionToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchGrantPermissions struct {
}
func (*awsRestjson1_deserializeOpBatchGrantPermissions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchGrantPermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorBatchGrantPermissions(response, &metadata)
}
output := &BatchGrantPermissionsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentBatchGrantPermissionsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorBatchGrantPermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchGrantPermissionsOutput(v **BatchGrantPermissionsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchGrantPermissionsOutput
if *v == nil {
sv = &BatchGrantPermissionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Failures":
if err := awsRestjson1_deserializeDocumentBatchPermissionsFailureList(&sv.Failures, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchRevokePermissions struct {
}
func (*awsRestjson1_deserializeOpBatchRevokePermissions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchRevokePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorBatchRevokePermissions(response, &metadata)
}
output := &BatchRevokePermissionsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentBatchRevokePermissionsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorBatchRevokePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchRevokePermissionsOutput(v **BatchRevokePermissionsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchRevokePermissionsOutput
if *v == nil {
sv = &BatchRevokePermissionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Failures":
if err := awsRestjson1_deserializeDocumentBatchPermissionsFailureList(&sv.Failures, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCancelTransaction struct {
}
func (*awsRestjson1_deserializeOpCancelTransaction) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCancelTransaction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorCancelTransaction(response, &metadata)
}
output := &CancelTransactionOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorCancelTransaction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("TransactionCommitInProgressException", errorCode):
return awsRestjson1_deserializeErrorTransactionCommitInProgressException(response, errorBody)
case strings.EqualFold("TransactionCommittedException", errorCode):
return awsRestjson1_deserializeErrorTransactionCommittedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpCommitTransaction struct {
}
func (*awsRestjson1_deserializeOpCommitTransaction) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCommitTransaction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorCommitTransaction(response, &metadata)
}
output := &CommitTransactionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentCommitTransactionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorCommitTransaction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("TransactionCanceledException", errorCode):
return awsRestjson1_deserializeErrorTransactionCanceledException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCommitTransactionOutput(v **CommitTransactionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CommitTransactionOutput
if *v == nil {
sv = &CommitTransactionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "TransactionStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TransactionStatus to be of type string, got %T instead", value)
}
sv.TransactionStatus = types.TransactionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateDataCellsFilter struct {
}
func (*awsRestjson1_deserializeOpCreateDataCellsFilter) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateDataCellsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorCreateDataCellsFilter(response, &metadata)
}
output := &CreateDataCellsFilterOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorCreateDataCellsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("AlreadyExistsException", errorCode):
return awsRestjson1_deserializeErrorAlreadyExistsException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("ResourceNumberLimitExceededException", errorCode):
return awsRestjson1_deserializeErrorResourceNumberLimitExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpCreateLFTag struct {
}
func (*awsRestjson1_deserializeOpCreateLFTag) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateLFTag) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorCreateLFTag(response, &metadata)
}
output := &CreateLFTagOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorCreateLFTag(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("ResourceNumberLimitExceededException", errorCode):
return awsRestjson1_deserializeErrorResourceNumberLimitExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteDataCellsFilter struct {
}
func (*awsRestjson1_deserializeOpDeleteDataCellsFilter) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteDataCellsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorDeleteDataCellsFilter(response, &metadata)
}
output := &DeleteDataCellsFilterOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteDataCellsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteLFTag struct {
}
func (*awsRestjson1_deserializeOpDeleteLFTag) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteLFTag) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorDeleteLFTag(response, &metadata)
}
output := &DeleteLFTagOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteLFTag(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteObjectsOnCancel struct {
}
func (*awsRestjson1_deserializeOpDeleteObjectsOnCancel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteObjectsOnCancel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorDeleteObjectsOnCancel(response, &metadata)
}
output := &DeleteObjectsOnCancelOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteObjectsOnCancel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("ResourceNotReadyException", errorCode):
return awsRestjson1_deserializeErrorResourceNotReadyException(response, errorBody)
case strings.EqualFold("TransactionCanceledException", errorCode):
return awsRestjson1_deserializeErrorTransactionCanceledException(response, errorBody)
case strings.EqualFold("TransactionCommittedException", errorCode):
return awsRestjson1_deserializeErrorTransactionCommittedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeregisterResource struct {
}
func (*awsRestjson1_deserializeOpDeregisterResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeregisterResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorDeregisterResource(response, &metadata)
}
output := &DeregisterResourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeregisterResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDescribeResource struct {
}
func (*awsRestjson1_deserializeOpDescribeResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorDescribeResource(response, &metadata)
}
output := &DescribeResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentDescribeResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDescribeResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeResourceOutput(v **DescribeResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeResourceOutput
if *v == nil {
sv = &DescribeResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ResourceInfo":
if err := awsRestjson1_deserializeDocumentResourceInfo(&sv.ResourceInfo, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeTransaction struct {
}
func (*awsRestjson1_deserializeOpDescribeTransaction) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeTransaction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorDescribeTransaction(response, &metadata)
}
output := &DescribeTransactionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentDescribeTransactionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDescribeTransaction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeTransactionOutput(v **DescribeTransactionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeTransactionOutput
if *v == nil {
sv = &DescribeTransactionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "TransactionDescription":
if err := awsRestjson1_deserializeDocumentTransactionDescription(&sv.TransactionDescription, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpExtendTransaction struct {
}
func (*awsRestjson1_deserializeOpExtendTransaction) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpExtendTransaction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorExtendTransaction(response, &metadata)
}
output := &ExtendTransactionOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorExtendTransaction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("TransactionCanceledException", errorCode):
return awsRestjson1_deserializeErrorTransactionCanceledException(response, errorBody)
case strings.EqualFold("TransactionCommitInProgressException", errorCode):
return awsRestjson1_deserializeErrorTransactionCommitInProgressException(response, errorBody)
case strings.EqualFold("TransactionCommittedException", errorCode):
return awsRestjson1_deserializeErrorTransactionCommittedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpGetDataCellsFilter struct {
}
func (*awsRestjson1_deserializeOpGetDataCellsFilter) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetDataCellsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetDataCellsFilter(response, &metadata)
}
output := &GetDataCellsFilterOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetDataCellsFilterOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetDataCellsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetDataCellsFilterOutput(v **GetDataCellsFilterOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetDataCellsFilterOutput
if *v == nil {
sv = &GetDataCellsFilterOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DataCellsFilter":
if err := awsRestjson1_deserializeDocumentDataCellsFilter(&sv.DataCellsFilter, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetDataLakeSettings struct {
}
func (*awsRestjson1_deserializeOpGetDataLakeSettings) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetDataLakeSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetDataLakeSettings(response, &metadata)
}
output := &GetDataLakeSettingsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetDataLakeSettingsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetDataLakeSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetDataLakeSettingsOutput(v **GetDataLakeSettingsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetDataLakeSettingsOutput
if *v == nil {
sv = &GetDataLakeSettingsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DataLakeSettings":
if err := awsRestjson1_deserializeDocumentDataLakeSettings(&sv.DataLakeSettings, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetEffectivePermissionsForPath struct {
}
func (*awsRestjson1_deserializeOpGetEffectivePermissionsForPath) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetEffectivePermissionsForPath) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetEffectivePermissionsForPath(response, &metadata)
}
output := &GetEffectivePermissionsForPathOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetEffectivePermissionsForPathOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetEffectivePermissionsForPath(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetEffectivePermissionsForPathOutput(v **GetEffectivePermissionsForPathOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetEffectivePermissionsForPathOutput
if *v == nil {
sv = &GetEffectivePermissionsForPathOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Permissions":
if err := awsRestjson1_deserializeDocumentPrincipalResourcePermissionsList(&sv.Permissions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetLFTag struct {
}
func (*awsRestjson1_deserializeOpGetLFTag) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetLFTag) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetLFTag(response, &metadata)
}
output := &GetLFTagOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetLFTagOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetLFTag(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetLFTagOutput(v **GetLFTagOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetLFTagOutput
if *v == nil {
sv = &GetLFTagOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.CatalogId = ptr.String(jtv)
}
case "TagKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LFTagKey to be of type string, got %T instead", value)
}
sv.TagKey = ptr.String(jtv)
}
case "TagValues":
if err := awsRestjson1_deserializeDocumentTagValueList(&sv.TagValues, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetQueryState struct {
}
func (*awsRestjson1_deserializeOpGetQueryState) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetQueryState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetQueryState(response, &metadata)
}
output := &GetQueryStateOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetQueryStateOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetQueryState(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetQueryStateOutput(v **GetQueryStateOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetQueryStateOutput
if *v == nil {
sv = &GetQueryStateOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Error":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessageString to be of type string, got %T instead", value)
}
sv.Error = ptr.String(jtv)
}
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected QueryStateString to be of type string, got %T instead", value)
}
sv.State = types.QueryStateString(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetQueryStatistics struct {
}
func (*awsRestjson1_deserializeOpGetQueryStatistics) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetQueryStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetQueryStatistics(response, &metadata)
}
output := &GetQueryStatisticsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetQueryStatisticsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetQueryStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ExpiredException", errorCode):
return awsRestjson1_deserializeErrorExpiredException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("StatisticsNotReadyYetException", errorCode):
return awsRestjson1_deserializeErrorStatisticsNotReadyYetException(response, errorBody)
case strings.EqualFold("ThrottledException", errorCode):
return awsRestjson1_deserializeErrorThrottledException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetQueryStatisticsOutput(v **GetQueryStatisticsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetQueryStatisticsOutput
if *v == nil {
sv = &GetQueryStatisticsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ExecutionStatistics":
if err := awsRestjson1_deserializeDocumentExecutionStatistics(&sv.ExecutionStatistics, value); err != nil {
return err
}
case "PlanningStatistics":
if err := awsRestjson1_deserializeDocumentPlanningStatistics(&sv.PlanningStatistics, value); err != nil {
return err
}
case "QuerySubmissionTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DateTime to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.QuerySubmissionTime = ptr.Time(t)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetResourceLFTags struct {
}
func (*awsRestjson1_deserializeOpGetResourceLFTags) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetResourceLFTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetResourceLFTags(response, &metadata)
}
output := &GetResourceLFTagsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetResourceLFTagsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetResourceLFTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("GlueEncryptionException", errorCode):
return awsRestjson1_deserializeErrorGlueEncryptionException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetResourceLFTagsOutput(v **GetResourceLFTagsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetResourceLFTagsOutput
if *v == nil {
sv = &GetResourceLFTagsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LFTagOnDatabase":
if err := awsRestjson1_deserializeDocumentLFTagsList(&sv.LFTagOnDatabase, value); err != nil {
return err
}
case "LFTagsOnColumns":
if err := awsRestjson1_deserializeDocumentColumnLFTagsList(&sv.LFTagsOnColumns, value); err != nil {
return err
}
case "LFTagsOnTable":
if err := awsRestjson1_deserializeDocumentLFTagsList(&sv.LFTagsOnTable, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetTableObjects struct {
}
func (*awsRestjson1_deserializeOpGetTableObjects) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetTableObjects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetTableObjects(response, &metadata)
}
output := &GetTableObjectsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetTableObjectsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetTableObjects(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("ResourceNotReadyException", errorCode):
return awsRestjson1_deserializeErrorResourceNotReadyException(response, errorBody)
case strings.EqualFold("TransactionCanceledException", errorCode):
return awsRestjson1_deserializeErrorTransactionCanceledException(response, errorBody)
case strings.EqualFold("TransactionCommittedException", errorCode):
return awsRestjson1_deserializeErrorTransactionCommittedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetTableObjectsOutput(v **GetTableObjectsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetTableObjectsOutput
if *v == nil {
sv = &GetTableObjectsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TokenString to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Objects":
if err := awsRestjson1_deserializeDocumentPartitionedTableObjectsList(&sv.Objects, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetTemporaryGluePartitionCredentials struct {
}
func (*awsRestjson1_deserializeOpGetTemporaryGluePartitionCredentials) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetTemporaryGluePartitionCredentials) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetTemporaryGluePartitionCredentials(response, &metadata)
}
output := &GetTemporaryGluePartitionCredentialsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetTemporaryGluePartitionCredentialsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetTemporaryGluePartitionCredentials(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("PermissionTypeMismatchException", errorCode):
return awsRestjson1_deserializeErrorPermissionTypeMismatchException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetTemporaryGluePartitionCredentialsOutput(v **GetTemporaryGluePartitionCredentialsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetTemporaryGluePartitionCredentialsOutput
if *v == nil {
sv = &GetTemporaryGluePartitionCredentialsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccessKeyIdString to be of type string, got %T instead", value)
}
sv.AccessKeyId = ptr.String(jtv)
}
case "Expiration":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Expiration = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected ExpirationTimestamp to be a JSON Number, got %T instead", value)
}
}
case "SecretAccessKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SecretAccessKeyString to be of type string, got %T instead", value)
}
sv.SecretAccessKey = ptr.String(jtv)
}
case "SessionToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SessionTokenString to be of type string, got %T instead", value)
}
sv.SessionToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetTemporaryGlueTableCredentials struct {
}
func (*awsRestjson1_deserializeOpGetTemporaryGlueTableCredentials) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetTemporaryGlueTableCredentials) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetTemporaryGlueTableCredentials(response, &metadata)
}
output := &GetTemporaryGlueTableCredentialsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetTemporaryGlueTableCredentialsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetTemporaryGlueTableCredentials(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("PermissionTypeMismatchException", errorCode):
return awsRestjson1_deserializeErrorPermissionTypeMismatchException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetTemporaryGlueTableCredentialsOutput(v **GetTemporaryGlueTableCredentialsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetTemporaryGlueTableCredentialsOutput
if *v == nil {
sv = &GetTemporaryGlueTableCredentialsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccessKeyIdString to be of type string, got %T instead", value)
}
sv.AccessKeyId = ptr.String(jtv)
}
case "Expiration":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Expiration = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected ExpirationTimestamp to be a JSON Number, got %T instead", value)
}
}
case "SecretAccessKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SecretAccessKeyString to be of type string, got %T instead", value)
}
sv.SecretAccessKey = ptr.String(jtv)
}
case "SessionToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SessionTokenString to be of type string, got %T instead", value)
}
sv.SessionToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetWorkUnitResults struct {
}
func (*awsRestjson1_deserializeOpGetWorkUnitResults) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetWorkUnitResults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetWorkUnitResults(response, &metadata)
}
output := &GetWorkUnitResultsOutput{}
out.Result = output
err = awsRestjson1_deserializeOpDocumentGetWorkUnitResultsOutput(output, response.Body)
if err != nil {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetWorkUnitResults(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ExpiredException", errorCode):
return awsRestjson1_deserializeErrorExpiredException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("ThrottledException", errorCode):
return awsRestjson1_deserializeErrorThrottledException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetWorkUnitResultsOutput(v *GetWorkUnitResultsOutput, body io.ReadCloser) error {
if v == nil {
return fmt.Errorf("unsupported deserialization of nil %T", v)
}
v.ResultStream = body
return nil
}
type awsRestjson1_deserializeOpGetWorkUnits struct {
}
func (*awsRestjson1_deserializeOpGetWorkUnits) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetWorkUnits) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGetWorkUnits(response, &metadata)
}
output := &GetWorkUnitsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGetWorkUnitsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetWorkUnits(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ExpiredException", errorCode):
return awsRestjson1_deserializeErrorExpiredException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("WorkUnitsNotReadyYetException", errorCode):
return awsRestjson1_deserializeErrorWorkUnitsNotReadyYetException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetWorkUnitsOutput(v **GetWorkUnitsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetWorkUnitsOutput
if *v == nil {
sv = &GetWorkUnitsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "QueryId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected QueryIdString to be of type string, got %T instead", value)
}
sv.QueryId = ptr.String(jtv)
}
case "WorkUnitRanges":
if err := awsRestjson1_deserializeDocumentWorkUnitRangeList(&sv.WorkUnitRanges, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGrantPermissions struct {
}
func (*awsRestjson1_deserializeOpGrantPermissions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGrantPermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGrantPermissions(response, &metadata)
}
output := &GrantPermissionsOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGrantPermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpListDataCellsFilter struct {
}
func (*awsRestjson1_deserializeOpListDataCellsFilter) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListDataCellsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorListDataCellsFilter(response, &metadata)
}
output := &ListDataCellsFilterOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentListDataCellsFilterOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorListDataCellsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListDataCellsFilterOutput(v **ListDataCellsFilterOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListDataCellsFilterOutput
if *v == nil {
sv = &ListDataCellsFilterOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DataCellsFilters":
if err := awsRestjson1_deserializeDocumentDataCellsFilterList(&sv.DataCellsFilters, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListLFTags struct {
}
func (*awsRestjson1_deserializeOpListLFTags) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListLFTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorListLFTags(response, &metadata)
}
output := &ListLFTagsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentListLFTagsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorListLFTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListLFTagsOutput(v **ListLFTagsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListLFTagsOutput
if *v == nil {
sv = &ListLFTagsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LFTags":
if err := awsRestjson1_deserializeDocumentLFTagsList(&sv.LFTags, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListPermissions struct {
}
func (*awsRestjson1_deserializeOpListPermissions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListPermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorListPermissions(response, &metadata)
}
output := &ListPermissionsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentListPermissionsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorListPermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListPermissionsOutput(v **ListPermissionsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListPermissionsOutput
if *v == nil {
sv = &ListPermissionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "PrincipalResourcePermissions":
if err := awsRestjson1_deserializeDocumentPrincipalResourcePermissionsList(&sv.PrincipalResourcePermissions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListResources struct {
}
func (*awsRestjson1_deserializeOpListResources) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorListResources(response, &metadata)
}
output := &ListResourcesOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentListResourcesOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorListResources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListResourcesOutput(v **ListResourcesOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListResourcesOutput
if *v == nil {
sv = &ListResourcesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ResourceInfoList":
if err := awsRestjson1_deserializeDocumentResourceInfoList(&sv.ResourceInfoList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListTableStorageOptimizers struct {
}
func (*awsRestjson1_deserializeOpListTableStorageOptimizers) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListTableStorageOptimizers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorListTableStorageOptimizers(response, &metadata)
}
output := &ListTableStorageOptimizersOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentListTableStorageOptimizersOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorListTableStorageOptimizers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListTableStorageOptimizersOutput(v **ListTableStorageOptimizersOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListTableStorageOptimizersOutput
if *v == nil {
sv = &ListTableStorageOptimizersOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "StorageOptimizerList":
if err := awsRestjson1_deserializeDocumentStorageOptimizerList(&sv.StorageOptimizerList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListTransactions struct {
}
func (*awsRestjson1_deserializeOpListTransactions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListTransactions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorListTransactions(response, &metadata)
}
output := &ListTransactionsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentListTransactionsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorListTransactions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListTransactionsOutput(v **ListTransactionsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListTransactionsOutput
if *v == nil {
sv = &ListTransactionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TokenString to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Transactions":
if err := awsRestjson1_deserializeDocumentTransactionDescriptionList(&sv.Transactions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpPutDataLakeSettings struct {
}
func (*awsRestjson1_deserializeOpPutDataLakeSettings) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpPutDataLakeSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorPutDataLakeSettings(response, &metadata)
}
output := &PutDataLakeSettingsOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorPutDataLakeSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpRegisterResource struct {
}
func (*awsRestjson1_deserializeOpRegisterResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpRegisterResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorRegisterResource(response, &metadata)
}
output := &RegisterResourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorRegisterResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("AlreadyExistsException", errorCode):
return awsRestjson1_deserializeErrorAlreadyExistsException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("ResourceNumberLimitExceededException", errorCode):
return awsRestjson1_deserializeErrorResourceNumberLimitExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpRemoveLFTagsFromResource struct {
}
func (*awsRestjson1_deserializeOpRemoveLFTagsFromResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpRemoveLFTagsFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorRemoveLFTagsFromResource(response, &metadata)
}
output := &RemoveLFTagsFromResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentRemoveLFTagsFromResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorRemoveLFTagsFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("GlueEncryptionException", errorCode):
return awsRestjson1_deserializeErrorGlueEncryptionException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentRemoveLFTagsFromResourceOutput(v **RemoveLFTagsFromResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *RemoveLFTagsFromResourceOutput
if *v == nil {
sv = &RemoveLFTagsFromResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Failures":
if err := awsRestjson1_deserializeDocumentLFTagErrors(&sv.Failures, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpRevokePermissions struct {
}
func (*awsRestjson1_deserializeOpRevokePermissions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpRevokePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorRevokePermissions(response, &metadata)
}
output := &RevokePermissionsOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorRevokePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpSearchDatabasesByLFTags struct {
}
func (*awsRestjson1_deserializeOpSearchDatabasesByLFTags) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpSearchDatabasesByLFTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorSearchDatabasesByLFTags(response, &metadata)
}
output := &SearchDatabasesByLFTagsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentSearchDatabasesByLFTagsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorSearchDatabasesByLFTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("GlueEncryptionException", errorCode):
return awsRestjson1_deserializeErrorGlueEncryptionException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentSearchDatabasesByLFTagsOutput(v **SearchDatabasesByLFTagsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *SearchDatabasesByLFTagsOutput
if *v == nil {
sv = &SearchDatabasesByLFTagsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DatabaseList":
if err := awsRestjson1_deserializeDocumentDatabaseLFTagsList(&sv.DatabaseList, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpSearchTablesByLFTags struct {
}
func (*awsRestjson1_deserializeOpSearchTablesByLFTags) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpSearchTablesByLFTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorSearchTablesByLFTags(response, &metadata)
}
output := &SearchTablesByLFTagsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentSearchTablesByLFTagsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorSearchTablesByLFTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("GlueEncryptionException", errorCode):
return awsRestjson1_deserializeErrorGlueEncryptionException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentSearchTablesByLFTagsOutput(v **SearchTablesByLFTagsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *SearchTablesByLFTagsOutput
if *v == nil {
sv = &SearchTablesByLFTagsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "TableList":
if err := awsRestjson1_deserializeDocumentTableLFTagsList(&sv.TableList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpStartQueryPlanning struct {
}
func (*awsRestjson1_deserializeOpStartQueryPlanning) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStartQueryPlanning) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorStartQueryPlanning(response, &metadata)
}
output := &StartQueryPlanningOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentStartQueryPlanningOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorStartQueryPlanning(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("ThrottledException", errorCode):
return awsRestjson1_deserializeErrorThrottledException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentStartQueryPlanningOutput(v **StartQueryPlanningOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *StartQueryPlanningOutput
if *v == nil {
sv = &StartQueryPlanningOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "QueryId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected QueryIdString to be of type string, got %T instead", value)
}
sv.QueryId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpStartTransaction struct {
}
func (*awsRestjson1_deserializeOpStartTransaction) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStartTransaction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorStartTransaction(response, &metadata)
}
output := &StartTransactionOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentStartTransactionOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorStartTransaction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentStartTransactionOutput(v **StartTransactionOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *StartTransactionOutput
if *v == nil {
sv = &StartTransactionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "TransactionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TransactionIdString to be of type string, got %T instead", value)
}
sv.TransactionId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateDataCellsFilter struct {
}
func (*awsRestjson1_deserializeOpUpdateDataCellsFilter) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateDataCellsFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorUpdateDataCellsFilter(response, &metadata)
}
output := &UpdateDataCellsFilterOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUpdateDataCellsFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateLFTag struct {
}
func (*awsRestjson1_deserializeOpUpdateLFTag) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateLFTag) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorUpdateLFTag(response, &metadata)
}
output := &UpdateLFTagOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUpdateLFTag(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateResource struct {
}
func (*awsRestjson1_deserializeOpUpdateResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorUpdateResource(response, &metadata)
}
output := &UpdateResourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUpdateResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateTableObjects struct {
}
func (*awsRestjson1_deserializeOpUpdateTableObjects) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateTableObjects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorUpdateTableObjects(response, &metadata)
}
output := &UpdateTableObjectsOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUpdateTableObjects(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("ConcurrentModificationException", errorCode):
return awsRestjson1_deserializeErrorConcurrentModificationException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("OperationTimeoutException", errorCode):
return awsRestjson1_deserializeErrorOperationTimeoutException(response, errorBody)
case strings.EqualFold("ResourceNotReadyException", errorCode):
return awsRestjson1_deserializeErrorResourceNotReadyException(response, errorBody)
case strings.EqualFold("TransactionCanceledException", errorCode):
return awsRestjson1_deserializeErrorTransactionCanceledException(response, errorBody)
case strings.EqualFold("TransactionCommitInProgressException", errorCode):
return awsRestjson1_deserializeErrorTransactionCommitInProgressException(response, errorBody)
case strings.EqualFold("TransactionCommittedException", errorCode):
return awsRestjson1_deserializeErrorTransactionCommittedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateTableStorageOptimizer struct {
}
func (*awsRestjson1_deserializeOpUpdateTableStorageOptimizer) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateTableStorageOptimizer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorUpdateTableStorageOptimizer(response, &metadata)
}
output := &UpdateTableStorageOptimizerOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentUpdateTableStorageOptimizerOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUpdateTableStorageOptimizer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("EntityNotFoundException", errorCode):
return awsRestjson1_deserializeErrorEntityNotFoundException(response, errorBody)
case strings.EqualFold("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateTableStorageOptimizerOutput(v **UpdateTableStorageOptimizerOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UpdateTableStorageOptimizerOutput
if *v == nil {
sv = &UpdateTableStorageOptimizerOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Result":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Result to be of type string, got %T instead", value)
}
sv.Result = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.AccessDeniedException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.AlreadyExistsException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentAlreadyExistsException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorConcurrentModificationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ConcurrentModificationException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentConcurrentModificationException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorEntityNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.EntityNotFoundException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentEntityNotFoundException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorExpiredException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ExpiredException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentExpiredException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorGlueEncryptionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.GlueEncryptionException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentGlueEncryptionException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorInternalServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalServiceException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentInternalServiceException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InvalidInputException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentInvalidInputException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorOperationTimeoutException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.OperationTimeoutException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentOperationTimeoutException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorPermissionTypeMismatchException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.PermissionTypeMismatchException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentPermissionTypeMismatchException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorResourceNotReadyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ResourceNotReadyException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentResourceNotReadyException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorResourceNumberLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ResourceNumberLimitExceededException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentResourceNumberLimitExceededException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorStatisticsNotReadyYetException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.StatisticsNotReadyYetException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentStatisticsNotReadyYetException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorThrottledException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ThrottledException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentThrottledException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorTransactionCanceledException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.TransactionCanceledException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentTransactionCanceledException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorTransactionCommitInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.TransactionCommitInProgressException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentTransactionCommitInProgressException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorTransactionCommittedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.TransactionCommittedException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentTransactionCommittedException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorWorkUnitsNotReadyYetException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.WorkUnitsNotReadyYetException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentWorkUnitsNotReadyYetException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AccessDeniedException
if *v == nil {
sv = &types.AccessDeniedException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAllRowsWildcard(v **types.AllRowsWildcard, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AllRowsWildcard
if *v == nil {
sv = &types.AllRowsWildcard{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlreadyExistsException(v **types.AlreadyExistsException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AlreadyExistsException
if *v == nil {
sv = &types.AlreadyExistsException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAuthorizedSessionTagValueList(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentBatchPermissionsFailureEntry(v **types.BatchPermissionsFailureEntry, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.BatchPermissionsFailureEntry
if *v == nil {
sv = &types.BatchPermissionsFailureEntry{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Error":
if err := awsRestjson1_deserializeDocumentErrorDetail(&sv.Error, value); err != nil {
return err
}
case "RequestEntry":
if err := awsRestjson1_deserializeDocumentBatchPermissionsRequestEntry(&sv.RequestEntry, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchPermissionsFailureList(v *[]types.BatchPermissionsFailureEntry, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.BatchPermissionsFailureEntry
if *v == nil {
cv = []types.BatchPermissionsFailureEntry{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchPermissionsFailureEntry
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchPermissionsFailureEntry(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentBatchPermissionsRequestEntry(v **types.BatchPermissionsRequestEntry, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.BatchPermissionsRequestEntry
if *v == nil {
sv = &types.BatchPermissionsRequestEntry{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Id":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Identifier to be of type string, got %T instead", value)
}
sv.Id = ptr.String(jtv)
}
case "Permissions":
if err := awsRestjson1_deserializeDocumentPermissionList(&sv.Permissions, value); err != nil {
return err
}
case "PermissionsWithGrantOption":
if err := awsRestjson1_deserializeDocumentPermissionList(&sv.PermissionsWithGrantOption, value); err != nil {
return err
}
case "Principal":
if err := awsRestjson1_deserializeDocumentDataLakePrincipal(&sv.Principal, value); err != nil {
return err
}
case "Resource":
if err := awsRestjson1_deserializeDocumentResource(&sv.Resource, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCatalogResource(v **types.CatalogResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CatalogResource
if *v == nil {
sv = &types.CatalogResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentColumnLFTag(v **types.ColumnLFTag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ColumnLFTag
if *v == nil {
sv = &types.ColumnLFTag{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LFTags":
if err := awsRestjson1_deserializeDocumentLFTagsList(&sv.LFTags, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentColumnLFTagsList(v *[]types.ColumnLFTag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.ColumnLFTag
if *v == nil {
cv = []types.ColumnLFTag{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ColumnLFTag
destAddr := &col
if err := awsRestjson1_deserializeDocumentColumnLFTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentColumnNames(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentColumnWildcard(v **types.ColumnWildcard, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ColumnWildcard
if *v == nil {
sv = &types.ColumnWildcard{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ExcludedColumnNames":
if err := awsRestjson1_deserializeDocumentColumnNames(&sv.ExcludedColumnNames, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ConcurrentModificationException
if *v == nil {
sv = &types.ConcurrentModificationException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDatabaseLFTagsList(v *[]types.TaggedDatabase, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.TaggedDatabase
if *v == nil {
cv = []types.TaggedDatabase{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TaggedDatabase
destAddr := &col
if err := awsRestjson1_deserializeDocumentTaggedDatabase(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDatabaseResource(v **types.DatabaseResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DatabaseResource
if *v == nil {
sv = &types.DatabaseResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.CatalogId = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDataCellsFilter(v **types.DataCellsFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DataCellsFilter
if *v == nil {
sv = &types.DataCellsFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ColumnNames":
if err := awsRestjson1_deserializeDocumentColumnNames(&sv.ColumnNames, value); err != nil {
return err
}
case "ColumnWildcard":
if err := awsRestjson1_deserializeDocumentColumnWildcard(&sv.ColumnWildcard, value); err != nil {
return err
}
case "DatabaseName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.DatabaseName = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "RowFilter":
if err := awsRestjson1_deserializeDocumentRowFilter(&sv.RowFilter, value); err != nil {
return err
}
case "TableCatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.TableCatalogId = ptr.String(jtv)
}
case "TableName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.TableName = ptr.String(jtv)
}
case "VersionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VersionString to be of type string, got %T instead", value)
}
sv.VersionId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDataCellsFilterList(v *[]types.DataCellsFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.DataCellsFilter
if *v == nil {
cv = []types.DataCellsFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DataCellsFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentDataCellsFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDataCellsFilterResource(v **types.DataCellsFilterResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DataCellsFilterResource
if *v == nil {
sv = &types.DataCellsFilterResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DatabaseName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.DatabaseName = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "TableCatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.TableCatalogId = ptr.String(jtv)
}
case "TableName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.TableName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDataLakePrincipal(v **types.DataLakePrincipal, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DataLakePrincipal
if *v == nil {
sv = &types.DataLakePrincipal{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DataLakePrincipalIdentifier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DataLakePrincipalString to be of type string, got %T instead", value)
}
sv.DataLakePrincipalIdentifier = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDataLakePrincipalList(v *[]types.DataLakePrincipal, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.DataLakePrincipal
if *v == nil {
cv = []types.DataLakePrincipal{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DataLakePrincipal
destAddr := &col
if err := awsRestjson1_deserializeDocumentDataLakePrincipal(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDataLakeSettings(v **types.DataLakeSettings, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DataLakeSettings
if *v == nil {
sv = &types.DataLakeSettings{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AllowExternalDataFiltering":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value)
}
sv.AllowExternalDataFiltering = ptr.Bool(jtv)
}
case "AuthorizedSessionTagValueList":
if err := awsRestjson1_deserializeDocumentAuthorizedSessionTagValueList(&sv.AuthorizedSessionTagValueList, value); err != nil {
return err
}
case "CreateDatabaseDefaultPermissions":
if err := awsRestjson1_deserializeDocumentPrincipalPermissionsList(&sv.CreateDatabaseDefaultPermissions, value); err != nil {
return err
}
case "CreateTableDefaultPermissions":
if err := awsRestjson1_deserializeDocumentPrincipalPermissionsList(&sv.CreateTableDefaultPermissions, value); err != nil {
return err
}
case "DataLakeAdmins":
if err := awsRestjson1_deserializeDocumentDataLakePrincipalList(&sv.DataLakeAdmins, value); err != nil {
return err
}
case "ExternalDataFilteringAllowList":
if err := awsRestjson1_deserializeDocumentDataLakePrincipalList(&sv.ExternalDataFilteringAllowList, value); err != nil {
return err
}
case "Parameters":
if err := awsRestjson1_deserializeDocumentParametersMap(&sv.Parameters, value); err != nil {
return err
}
case "TrustedResourceOwners":
if err := awsRestjson1_deserializeDocumentTrustedResourceOwners(&sv.TrustedResourceOwners, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDataLocationResource(v **types.DataLocationResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DataLocationResource
if *v == nil {
sv = &types.DataLocationResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.CatalogId = ptr.String(jtv)
}
case "ResourceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArnString to be of type string, got %T instead", value)
}
sv.ResourceArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetailsMap(v **types.DetailsMap, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DetailsMap
if *v == nil {
sv = &types.DetailsMap{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ResourceShare":
if err := awsRestjson1_deserializeDocumentResourceShareList(&sv.ResourceShare, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEntityNotFoundException(v **types.EntityNotFoundException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EntityNotFoundException
if *v == nil {
sv = &types.EntityNotFoundException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentErrorDetail(v **types.ErrorDetail, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ErrorDetail
if *v == nil {
sv = &types.ErrorDetail{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ErrorCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.ErrorCode = ptr.String(jtv)
}
case "ErrorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DescriptionString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExecutionStatistics(v **types.ExecutionStatistics, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ExecutionStatistics
if *v == nil {
sv = &types.ExecutionStatistics{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AverageExecutionTimeMillis":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected NumberOfMilliseconds to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.AverageExecutionTimeMillis = i64
}
case "DataScannedBytes":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected NumberOfBytes to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DataScannedBytes = i64
}
case "WorkUnitsExecutedCount":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected NumberOfItems to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.WorkUnitsExecutedCount = i64
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExpiredException(v **types.ExpiredException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ExpiredException
if *v == nil {
sv = &types.ExpiredException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExpression(v *[]types.LFTag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.LFTag
if *v == nil {
cv = []types.LFTag{}
} else {
cv = *v
}
for _, value := range shape {
var col types.LFTag
destAddr := &col
if err := awsRestjson1_deserializeDocumentLFTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentGlueEncryptionException(v **types.GlueEncryptionException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.GlueEncryptionException
if *v == nil {
sv = &types.GlueEncryptionException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInternalServiceException(v **types.InternalServiceException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InternalServiceException
if *v == nil {
sv = &types.InternalServiceException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InvalidInputException
if *v == nil {
sv = &types.InvalidInputException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLFTag(v **types.LFTag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LFTag
if *v == nil {
sv = &types.LFTag{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "TagKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LFTagKey to be of type string, got %T instead", value)
}
sv.TagKey = ptr.String(jtv)
}
case "TagValues":
if err := awsRestjson1_deserializeDocumentTagValueList(&sv.TagValues, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLFTagError(v **types.LFTagError, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LFTagError
if *v == nil {
sv = &types.LFTagError{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Error":
if err := awsRestjson1_deserializeDocumentErrorDetail(&sv.Error, value); err != nil {
return err
}
case "LFTag":
if err := awsRestjson1_deserializeDocumentLFTagPair(&sv.LFTag, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLFTagErrors(v *[]types.LFTagError, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.LFTagError
if *v == nil {
cv = []types.LFTagError{}
} else {
cv = *v
}
for _, value := range shape {
var col types.LFTagError
destAddr := &col
if err := awsRestjson1_deserializeDocumentLFTagError(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentLFTagKeyResource(v **types.LFTagKeyResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LFTagKeyResource
if *v == nil {
sv = &types.LFTagKeyResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.CatalogId = ptr.String(jtv)
}
case "TagKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.TagKey = ptr.String(jtv)
}
case "TagValues":
if err := awsRestjson1_deserializeDocumentTagValueList(&sv.TagValues, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLFTagPair(v **types.LFTagPair, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LFTagPair
if *v == nil {
sv = &types.LFTagPair{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.CatalogId = ptr.String(jtv)
}
case "TagKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LFTagKey to be of type string, got %T instead", value)
}
sv.TagKey = ptr.String(jtv)
}
case "TagValues":
if err := awsRestjson1_deserializeDocumentTagValueList(&sv.TagValues, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLFTagPolicyResource(v **types.LFTagPolicyResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LFTagPolicyResource
if *v == nil {
sv = &types.LFTagPolicyResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.CatalogId = ptr.String(jtv)
}
case "Expression":
if err := awsRestjson1_deserializeDocumentExpression(&sv.Expression, value); err != nil {
return err
}
case "ResourceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
}
sv.ResourceType = types.ResourceType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLFTagsList(v *[]types.LFTagPair, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.LFTagPair
if *v == nil {
cv = []types.LFTagPair{}
} else {
cv = *v
}
for _, value := range shape {
var col types.LFTagPair
destAddr := &col
if err := awsRestjson1_deserializeDocumentLFTagPair(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentOperationTimeoutException(v **types.OperationTimeoutException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.OperationTimeoutException
if *v == nil {
sv = &types.OperationTimeoutException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentParametersMap(v *map[string]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var mv map[string]string
if *v == nil {
mv = map[string]string{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ParametersMapValue to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsRestjson1_deserializeDocumentPartitionedTableObjectsList(v *[]types.PartitionObjects, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.PartitionObjects
if *v == nil {
cv = []types.PartitionObjects{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PartitionObjects
destAddr := &col
if err := awsRestjson1_deserializeDocumentPartitionObjects(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentPartitionObjects(v **types.PartitionObjects, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PartitionObjects
if *v == nil {
sv = &types.PartitionObjects{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Objects":
if err := awsRestjson1_deserializeDocumentTableObjectList(&sv.Objects, value); err != nil {
return err
}
case "PartitionValues":
if err := awsRestjson1_deserializeDocumentPartitionValuesList(&sv.PartitionValues, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPartitionValuesList(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PartitionValueString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentPermissionList(v *[]types.Permission, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.Permission
if *v == nil {
cv = []types.Permission{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Permission
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Permission to be of type string, got %T instead", value)
}
col = types.Permission(jtv)
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentPermissionTypeMismatchException(v **types.PermissionTypeMismatchException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PermissionTypeMismatchException
if *v == nil {
sv = &types.PermissionTypeMismatchException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPlanningStatistics(v **types.PlanningStatistics, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PlanningStatistics
if *v == nil {
sv = &types.PlanningStatistics{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EstimatedDataToScanBytes":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected NumberOfBytes to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.EstimatedDataToScanBytes = i64
}
case "PlanningTimeMillis":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected NumberOfMilliseconds to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.PlanningTimeMillis = i64
}
case "QueueTimeMillis":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected NumberOfMilliseconds to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.QueueTimeMillis = i64
}
case "WorkUnitsGeneratedCount":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected NumberOfItems to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.WorkUnitsGeneratedCount = i64
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPrincipalPermissions(v **types.PrincipalPermissions, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PrincipalPermissions
if *v == nil {
sv = &types.PrincipalPermissions{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Permissions":
if err := awsRestjson1_deserializeDocumentPermissionList(&sv.Permissions, value); err != nil {
return err
}
case "Principal":
if err := awsRestjson1_deserializeDocumentDataLakePrincipal(&sv.Principal, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPrincipalPermissionsList(v *[]types.PrincipalPermissions, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.PrincipalPermissions
if *v == nil {
cv = []types.PrincipalPermissions{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PrincipalPermissions
destAddr := &col
if err := awsRestjson1_deserializeDocumentPrincipalPermissions(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentPrincipalResourcePermissions(v **types.PrincipalResourcePermissions, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PrincipalResourcePermissions
if *v == nil {
sv = &types.PrincipalResourcePermissions{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdditionalDetails":
if err := awsRestjson1_deserializeDocumentDetailsMap(&sv.AdditionalDetails, value); err != nil {
return err
}
case "Permissions":
if err := awsRestjson1_deserializeDocumentPermissionList(&sv.Permissions, value); err != nil {
return err
}
case "PermissionsWithGrantOption":
if err := awsRestjson1_deserializeDocumentPermissionList(&sv.PermissionsWithGrantOption, value); err != nil {
return err
}
case "Principal":
if err := awsRestjson1_deserializeDocumentDataLakePrincipal(&sv.Principal, value); err != nil {
return err
}
case "Resource":
if err := awsRestjson1_deserializeDocumentResource(&sv.Resource, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPrincipalResourcePermissionsList(v *[]types.PrincipalResourcePermissions, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.PrincipalResourcePermissions
if *v == nil {
cv = []types.PrincipalResourcePermissions{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PrincipalResourcePermissions
destAddr := &col
if err := awsRestjson1_deserializeDocumentPrincipalResourcePermissions(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentResource(v **types.Resource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Resource
if *v == nil {
sv = &types.Resource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Catalog":
if err := awsRestjson1_deserializeDocumentCatalogResource(&sv.Catalog, value); err != nil {
return err
}
case "Database":
if err := awsRestjson1_deserializeDocumentDatabaseResource(&sv.Database, value); err != nil {
return err
}
case "DataCellsFilter":
if err := awsRestjson1_deserializeDocumentDataCellsFilterResource(&sv.DataCellsFilter, value); err != nil {
return err
}
case "DataLocation":
if err := awsRestjson1_deserializeDocumentDataLocationResource(&sv.DataLocation, value); err != nil {
return err
}
case "LFTag":
if err := awsRestjson1_deserializeDocumentLFTagKeyResource(&sv.LFTag, value); err != nil {
return err
}
case "LFTagPolicy":
if err := awsRestjson1_deserializeDocumentLFTagPolicyResource(&sv.LFTagPolicy, value); err != nil {
return err
}
case "Table":
if err := awsRestjson1_deserializeDocumentTableResource(&sv.Table, value); err != nil {
return err
}
case "TableWithColumns":
if err := awsRestjson1_deserializeDocumentTableWithColumnsResource(&sv.TableWithColumns, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceInfo(v **types.ResourceInfo, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceInfo
if *v == nil {
sv = &types.ResourceInfo{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LastModified":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected LastModifiedTimestamp to be a JSON Number, got %T instead", value)
}
}
case "ResourceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArnString to be of type string, got %T instead", value)
}
sv.ResourceArn = ptr.String(jtv)
}
case "RoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IAMRoleArn to be of type string, got %T instead", value)
}
sv.RoleArn = ptr.String(jtv)
}
case "WithFederation":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value)
}
sv.WithFederation = ptr.Bool(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceInfoList(v *[]types.ResourceInfo, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.ResourceInfo
if *v == nil {
cv = []types.ResourceInfo{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ResourceInfo
destAddr := &col
if err := awsRestjson1_deserializeDocumentResourceInfo(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentResourceNotReadyException(v **types.ResourceNotReadyException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceNotReadyException
if *v == nil {
sv = &types.ResourceNotReadyException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceNumberLimitExceededException(v **types.ResourceNumberLimitExceededException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceNumberLimitExceededException
if *v == nil {
sv = &types.ResourceNumberLimitExceededException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceShareList(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RAMResourceShareArn to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentRowFilter(v **types.RowFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.RowFilter
if *v == nil {
sv = &types.RowFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AllRowsWildcard":
if err := awsRestjson1_deserializeDocumentAllRowsWildcard(&sv.AllRowsWildcard, value); err != nil {
return err
}
case "FilterExpression":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PredicateString to be of type string, got %T instead", value)
}
sv.FilterExpression = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStatisticsNotReadyYetException(v **types.StatisticsNotReadyYetException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.StatisticsNotReadyYetException
if *v == nil {
sv = &types.StatisticsNotReadyYetException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStorageOptimizer(v **types.StorageOptimizer, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.StorageOptimizer
if *v == nil {
sv = &types.StorageOptimizer{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Config":
if err := awsRestjson1_deserializeDocumentStorageOptimizerConfig(&sv.Config, value); err != nil {
return err
}
case "ErrorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "LastRunDetails":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.LastRunDetails = ptr.String(jtv)
}
case "StorageOptimizerType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OptimizerType to be of type string, got %T instead", value)
}
sv.StorageOptimizerType = types.OptimizerType(jtv)
}
case "Warnings":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Warnings = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStorageOptimizerConfig(v *map[string]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var mv map[string]string
if *v == nil {
mv = map[string]string{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StorageOptimizerConfigValue to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsRestjson1_deserializeDocumentStorageOptimizerList(v *[]types.StorageOptimizer, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.StorageOptimizer
if *v == nil {
cv = []types.StorageOptimizer{}
} else {
cv = *v
}
for _, value := range shape {
var col types.StorageOptimizer
destAddr := &col
if err := awsRestjson1_deserializeDocumentStorageOptimizer(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTableLFTagsList(v *[]types.TaggedTable, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.TaggedTable
if *v == nil {
cv = []types.TaggedTable{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TaggedTable
destAddr := &col
if err := awsRestjson1_deserializeDocumentTaggedTable(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTableObject(v **types.TableObject, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TableObject
if *v == nil {
sv = &types.TableObject{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ETag":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ETagString to be of type string, got %T instead", value)
}
sv.ETag = ptr.String(jtv)
}
case "Size":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected ObjectSize to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Size = i64
}
case "Uri":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected URI to be of type string, got %T instead", value)
}
sv.Uri = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTableObjectList(v *[]types.TableObject, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.TableObject
if *v == nil {
cv = []types.TableObject{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TableObject
destAddr := &col
if err := awsRestjson1_deserializeDocumentTableObject(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTableResource(v **types.TableResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TableResource
if *v == nil {
sv = &types.TableResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.CatalogId = ptr.String(jtv)
}
case "DatabaseName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.DatabaseName = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "TableWildcard":
if err := awsRestjson1_deserializeDocumentTableWildcard(&sv.TableWildcard, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTableWildcard(v **types.TableWildcard, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TableWildcard
if *v == nil {
sv = &types.TableWildcard{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTableWithColumnsResource(v **types.TableWithColumnsResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TableWithColumnsResource
if *v == nil {
sv = &types.TableWithColumnsResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CatalogId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
sv.CatalogId = ptr.String(jtv)
}
case "ColumnNames":
if err := awsRestjson1_deserializeDocumentColumnNames(&sv.ColumnNames, value); err != nil {
return err
}
case "ColumnWildcard":
if err := awsRestjson1_deserializeDocumentColumnWildcard(&sv.ColumnWildcard, value); err != nil {
return err
}
case "DatabaseName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.DatabaseName = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NameString to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTaggedDatabase(v **types.TaggedDatabase, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TaggedDatabase
if *v == nil {
sv = &types.TaggedDatabase{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Database":
if err := awsRestjson1_deserializeDocumentDatabaseResource(&sv.Database, value); err != nil {
return err
}
case "LFTags":
if err := awsRestjson1_deserializeDocumentLFTagsList(&sv.LFTags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTaggedTable(v **types.TaggedTable, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TaggedTable
if *v == nil {
sv = &types.TaggedTable{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LFTagOnDatabase":
if err := awsRestjson1_deserializeDocumentLFTagsList(&sv.LFTagOnDatabase, value); err != nil {
return err
}
case "LFTagsOnColumns":
if err := awsRestjson1_deserializeDocumentColumnLFTagsList(&sv.LFTagsOnColumns, value); err != nil {
return err
}
case "LFTagsOnTable":
if err := awsRestjson1_deserializeDocumentLFTagsList(&sv.LFTagsOnTable, value); err != nil {
return err
}
case "Table":
if err := awsRestjson1_deserializeDocumentTableResource(&sv.Table, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTagValueList(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LFTagValue to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentThrottledException(v **types.ThrottledException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThrottledException
if *v == nil {
sv = &types.ThrottledException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTransactionCanceledException(v **types.TransactionCanceledException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TransactionCanceledException
if *v == nil {
sv = &types.TransactionCanceledException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTransactionCommitInProgressException(v **types.TransactionCommitInProgressException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TransactionCommitInProgressException
if *v == nil {
sv = &types.TransactionCommitInProgressException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTransactionCommittedException(v **types.TransactionCommittedException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TransactionCommittedException
if *v == nil {
sv = &types.TransactionCommittedException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTransactionDescription(v **types.TransactionDescription, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TransactionDescription
if *v == nil {
sv = &types.TransactionDescription{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "TransactionEndTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.TransactionEndTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "TransactionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TransactionIdString to be of type string, got %T instead", value)
}
sv.TransactionId = ptr.String(jtv)
}
case "TransactionStartTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.TransactionStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "TransactionStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TransactionStatus to be of type string, got %T instead", value)
}
sv.TransactionStatus = types.TransactionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTransactionDescriptionList(v *[]types.TransactionDescription, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.TransactionDescription
if *v == nil {
cv = []types.TransactionDescription{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TransactionDescription
destAddr := &col
if err := awsRestjson1_deserializeDocumentTransactionDescription(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTrustedResourceOwners(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CatalogIdString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentWorkUnitRange(v **types.WorkUnitRange, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.WorkUnitRange
if *v == nil {
sv = &types.WorkUnitRange{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "WorkUnitIdMax":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected WorkUnitIdLong to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.WorkUnitIdMax = i64
}
case "WorkUnitIdMin":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected WorkUnitIdLong to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.WorkUnitIdMin = i64
}
case "WorkUnitToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected WorkUnitTokenString to be of type string, got %T instead", value)
}
sv.WorkUnitToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentWorkUnitRangeList(v *[]types.WorkUnitRange, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.WorkUnitRange
if *v == nil {
cv = []types.WorkUnitRange{}
} else {
cv = *v
}
for _, value := range shape {
var col types.WorkUnitRange
destAddr := &col
if err := awsRestjson1_deserializeDocumentWorkUnitRange(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentWorkUnitsNotReadyYetException(v **types.WorkUnitsNotReadyYetException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.WorkUnitsNotReadyYetException
if *v == nil {
sv = &types.WorkUnitsNotReadyYetException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageString to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 10,936 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package lakeformation provides the API client, operations, and parameter types
// for AWS Lake Formation.
//
// Lake Formation Defines the public endpoint for the Lake Formation service.
package lakeformation
| 8 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/lakeformation/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// EndpointResolverFunc is a helper utility that wraps a function so it satisfies
// the EndpointResolver interface. This is useful when you want to add additional
// endpoint resolving logic, or stub out specific endpoints with custom values.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// EndpointResolverFromURL returns an EndpointResolver configured using the
// provided endpoint url. By default, the resolved endpoint resolver uses the
// client region as signing region, and the endpoint source is set to
// EndpointSourceCustom.You can provide functional options to configure endpoint
// values for the resolved endpoint.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "lakeformation"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package lakeformation
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.21.7"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
type awsRestjson1_serializeOpAddLFTagsToResource struct {
}
func (*awsRestjson1_serializeOpAddLFTagsToResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAddLFTagsToResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*AddLFTagsToResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/AddLFTagsToResource")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAddLFTagsToResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsAddLFTagsToResourceInput(v *AddLFTagsToResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentAddLFTagsToResourceInput(v *AddLFTagsToResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.LFTags != nil {
ok := object.Key("LFTags")
if err := awsRestjson1_serializeDocumentLFTagsList(v.LFTags, ok); err != nil {
return err
}
}
if v.Resource != nil {
ok := object.Key("Resource")
if err := awsRestjson1_serializeDocumentResource(v.Resource, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpAssumeDecoratedRoleWithSAML struct {
}
func (*awsRestjson1_serializeOpAssumeDecoratedRoleWithSAML) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssumeDecoratedRoleWithSAML) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*AssumeDecoratedRoleWithSAMLInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/AssumeDecoratedRoleWithSAML")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssumeDecoratedRoleWithSAMLInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsAssumeDecoratedRoleWithSAMLInput(v *AssumeDecoratedRoleWithSAMLInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentAssumeDecoratedRoleWithSAMLInput(v *AssumeDecoratedRoleWithSAMLInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DurationSeconds != nil {
ok := object.Key("DurationSeconds")
ok.Integer(*v.DurationSeconds)
}
if v.PrincipalArn != nil {
ok := object.Key("PrincipalArn")
ok.String(*v.PrincipalArn)
}
if v.RoleArn != nil {
ok := object.Key("RoleArn")
ok.String(*v.RoleArn)
}
if v.SAMLAssertion != nil {
ok := object.Key("SAMLAssertion")
ok.String(*v.SAMLAssertion)
}
return nil
}
type awsRestjson1_serializeOpBatchGrantPermissions struct {
}
func (*awsRestjson1_serializeOpBatchGrantPermissions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchGrantPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*BatchGrantPermissionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/BatchGrantPermissions")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentBatchGrantPermissionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsBatchGrantPermissionsInput(v *BatchGrantPermissionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchGrantPermissionsInput(v *BatchGrantPermissionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Entries != nil {
ok := object.Key("Entries")
if err := awsRestjson1_serializeDocumentBatchPermissionsRequestEntryList(v.Entries, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchRevokePermissions struct {
}
func (*awsRestjson1_serializeOpBatchRevokePermissions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchRevokePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*BatchRevokePermissionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/BatchRevokePermissions")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentBatchRevokePermissionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsBatchRevokePermissionsInput(v *BatchRevokePermissionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchRevokePermissionsInput(v *BatchRevokePermissionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Entries != nil {
ok := object.Key("Entries")
if err := awsRestjson1_serializeDocumentBatchPermissionsRequestEntryList(v.Entries, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCancelTransaction struct {
}
func (*awsRestjson1_serializeOpCancelTransaction) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCancelTransaction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CancelTransactionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/CancelTransaction")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCancelTransactionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCancelTransactionInput(v *CancelTransactionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCancelTransactionInput(v *CancelTransactionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TransactionId != nil {
ok := object.Key("TransactionId")
ok.String(*v.TransactionId)
}
return nil
}
type awsRestjson1_serializeOpCommitTransaction struct {
}
func (*awsRestjson1_serializeOpCommitTransaction) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCommitTransaction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CommitTransactionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/CommitTransaction")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCommitTransactionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCommitTransactionInput(v *CommitTransactionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCommitTransactionInput(v *CommitTransactionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TransactionId != nil {
ok := object.Key("TransactionId")
ok.String(*v.TransactionId)
}
return nil
}
type awsRestjson1_serializeOpCreateDataCellsFilter struct {
}
func (*awsRestjson1_serializeOpCreateDataCellsFilter) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateDataCellsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateDataCellsFilterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/CreateDataCellsFilter")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateDataCellsFilterInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateDataCellsFilterInput(v *CreateDataCellsFilterInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateDataCellsFilterInput(v *CreateDataCellsFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TableData != nil {
ok := object.Key("TableData")
if err := awsRestjson1_serializeDocumentDataCellsFilter(v.TableData, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateLFTag struct {
}
func (*awsRestjson1_serializeOpCreateLFTag) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateLFTag) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateLFTagInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/CreateLFTag")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateLFTagInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateLFTagInput(v *CreateLFTagInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateLFTagInput(v *CreateLFTagInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.TagKey != nil {
ok := object.Key("TagKey")
ok.String(*v.TagKey)
}
if v.TagValues != nil {
ok := object.Key("TagValues")
if err := awsRestjson1_serializeDocumentTagValueList(v.TagValues, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteDataCellsFilter struct {
}
func (*awsRestjson1_serializeOpDeleteDataCellsFilter) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteDataCellsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteDataCellsFilterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/DeleteDataCellsFilter")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDeleteDataCellsFilterInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteDataCellsFilterInput(v *DeleteDataCellsFilterInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDeleteDataCellsFilterInput(v *DeleteDataCellsFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.TableCatalogId != nil {
ok := object.Key("TableCatalogId")
ok.String(*v.TableCatalogId)
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
return nil
}
type awsRestjson1_serializeOpDeleteLFTag struct {
}
func (*awsRestjson1_serializeOpDeleteLFTag) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteLFTag) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteLFTagInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/DeleteLFTag")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDeleteLFTagInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteLFTagInput(v *DeleteLFTagInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDeleteLFTagInput(v *DeleteLFTagInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.TagKey != nil {
ok := object.Key("TagKey")
ok.String(*v.TagKey)
}
return nil
}
type awsRestjson1_serializeOpDeleteObjectsOnCancel struct {
}
func (*awsRestjson1_serializeOpDeleteObjectsOnCancel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteObjectsOnCancel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteObjectsOnCancelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/DeleteObjectsOnCancel")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDeleteObjectsOnCancelInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteObjectsOnCancelInput(v *DeleteObjectsOnCancelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDeleteObjectsOnCancelInput(v *DeleteObjectsOnCancelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.Objects != nil {
ok := object.Key("Objects")
if err := awsRestjson1_serializeDocumentVirtualObjectList(v.Objects, ok); err != nil {
return err
}
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
if v.TransactionId != nil {
ok := object.Key("TransactionId")
ok.String(*v.TransactionId)
}
return nil
}
type awsRestjson1_serializeOpDeregisterResource struct {
}
func (*awsRestjson1_serializeOpDeregisterResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeregisterResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeregisterResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/DeregisterResource")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDeregisterResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeregisterResourceInput(v *DeregisterResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDeregisterResourceInput(v *DeregisterResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
return nil
}
type awsRestjson1_serializeOpDescribeResource struct {
}
func (*awsRestjson1_serializeOpDescribeResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/DescribeResource")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDescribeResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDescribeResourceInput(v *DescribeResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDescribeResourceInput(v *DescribeResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
return nil
}
type awsRestjson1_serializeOpDescribeTransaction struct {
}
func (*awsRestjson1_serializeOpDescribeTransaction) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeTransaction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DescribeTransactionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/DescribeTransaction")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDescribeTransactionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDescribeTransactionInput(v *DescribeTransactionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDescribeTransactionInput(v *DescribeTransactionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TransactionId != nil {
ok := object.Key("TransactionId")
ok.String(*v.TransactionId)
}
return nil
}
type awsRestjson1_serializeOpExtendTransaction struct {
}
func (*awsRestjson1_serializeOpExtendTransaction) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpExtendTransaction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ExtendTransactionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ExtendTransaction")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentExtendTransactionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsExtendTransactionInput(v *ExtendTransactionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentExtendTransactionInput(v *ExtendTransactionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TransactionId != nil {
ok := object.Key("TransactionId")
ok.String(*v.TransactionId)
}
return nil
}
type awsRestjson1_serializeOpGetDataCellsFilter struct {
}
func (*awsRestjson1_serializeOpGetDataCellsFilter) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDataCellsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetDataCellsFilterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetDataCellsFilter")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetDataCellsFilterInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetDataCellsFilterInput(v *GetDataCellsFilterInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetDataCellsFilterInput(v *GetDataCellsFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.TableCatalogId != nil {
ok := object.Key("TableCatalogId")
ok.String(*v.TableCatalogId)
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
return nil
}
type awsRestjson1_serializeOpGetDataLakeSettings struct {
}
func (*awsRestjson1_serializeOpGetDataLakeSettings) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDataLakeSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetDataLakeSettingsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetDataLakeSettings")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetDataLakeSettingsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetDataLakeSettingsInput(v *GetDataLakeSettingsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetDataLakeSettingsInput(v *GetDataLakeSettingsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
return nil
}
type awsRestjson1_serializeOpGetEffectivePermissionsForPath struct {
}
func (*awsRestjson1_serializeOpGetEffectivePermissionsForPath) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetEffectivePermissionsForPath) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetEffectivePermissionsForPathInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetEffectivePermissionsForPath")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetEffectivePermissionsForPathInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetEffectivePermissionsForPathInput(v *GetEffectivePermissionsForPathInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetEffectivePermissionsForPathInput(v *GetEffectivePermissionsForPathInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
return nil
}
type awsRestjson1_serializeOpGetLFTag struct {
}
func (*awsRestjson1_serializeOpGetLFTag) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetLFTag) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetLFTagInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetLFTag")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetLFTagInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetLFTagInput(v *GetLFTagInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetLFTagInput(v *GetLFTagInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.TagKey != nil {
ok := object.Key("TagKey")
ok.String(*v.TagKey)
}
return nil
}
type awsRestjson1_serializeOpGetQueryState struct {
}
func (*awsRestjson1_serializeOpGetQueryState) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetQueryState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetQueryStateInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetQueryState")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetQueryStateInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetQueryStateInput(v *GetQueryStateInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetQueryStateInput(v *GetQueryStateInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.QueryId != nil {
ok := object.Key("QueryId")
ok.String(*v.QueryId)
}
return nil
}
type awsRestjson1_serializeOpGetQueryStatistics struct {
}
func (*awsRestjson1_serializeOpGetQueryStatistics) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetQueryStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetQueryStatisticsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetQueryStatistics")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetQueryStatisticsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetQueryStatisticsInput(v *GetQueryStatisticsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetQueryStatisticsInput(v *GetQueryStatisticsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.QueryId != nil {
ok := object.Key("QueryId")
ok.String(*v.QueryId)
}
return nil
}
type awsRestjson1_serializeOpGetResourceLFTags struct {
}
func (*awsRestjson1_serializeOpGetResourceLFTags) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetResourceLFTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetResourceLFTagsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetResourceLFTags")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetResourceLFTagsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetResourceLFTagsInput(v *GetResourceLFTagsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetResourceLFTagsInput(v *GetResourceLFTagsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Resource != nil {
ok := object.Key("Resource")
if err := awsRestjson1_serializeDocumentResource(v.Resource, ok); err != nil {
return err
}
}
if v.ShowAssignedLFTags != nil {
ok := object.Key("ShowAssignedLFTags")
ok.Boolean(*v.ShowAssignedLFTags)
}
return nil
}
type awsRestjson1_serializeOpGetTableObjects struct {
}
func (*awsRestjson1_serializeOpGetTableObjects) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetTableObjects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetTableObjectsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetTableObjects")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetTableObjectsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetTableObjectsInput(v *GetTableObjectsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetTableObjectsInput(v *GetTableObjectsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.PartitionPredicate != nil {
ok := object.Key("PartitionPredicate")
ok.String(*v.PartitionPredicate)
}
if v.QueryAsOfTime != nil {
ok := object.Key("QueryAsOfTime")
ok.Double(smithytime.FormatEpochSeconds(*v.QueryAsOfTime))
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
if v.TransactionId != nil {
ok := object.Key("TransactionId")
ok.String(*v.TransactionId)
}
return nil
}
type awsRestjson1_serializeOpGetTemporaryGluePartitionCredentials struct {
}
func (*awsRestjson1_serializeOpGetTemporaryGluePartitionCredentials) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetTemporaryGluePartitionCredentials) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetTemporaryGluePartitionCredentialsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetTemporaryGluePartitionCredentials")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetTemporaryGluePartitionCredentialsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetTemporaryGluePartitionCredentialsInput(v *GetTemporaryGluePartitionCredentialsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetTemporaryGluePartitionCredentialsInput(v *GetTemporaryGluePartitionCredentialsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AuditContext != nil {
ok := object.Key("AuditContext")
if err := awsRestjson1_serializeDocumentAuditContext(v.AuditContext, ok); err != nil {
return err
}
}
if v.DurationSeconds != nil {
ok := object.Key("DurationSeconds")
ok.Integer(*v.DurationSeconds)
}
if v.Partition != nil {
ok := object.Key("Partition")
if err := awsRestjson1_serializeDocumentPartitionValueList(v.Partition, ok); err != nil {
return err
}
}
if v.Permissions != nil {
ok := object.Key("Permissions")
if err := awsRestjson1_serializeDocumentPermissionList(v.Permissions, ok); err != nil {
return err
}
}
if v.SupportedPermissionTypes != nil {
ok := object.Key("SupportedPermissionTypes")
if err := awsRestjson1_serializeDocumentPermissionTypeList(v.SupportedPermissionTypes, ok); err != nil {
return err
}
}
if v.TableArn != nil {
ok := object.Key("TableArn")
ok.String(*v.TableArn)
}
return nil
}
type awsRestjson1_serializeOpGetTemporaryGlueTableCredentials struct {
}
func (*awsRestjson1_serializeOpGetTemporaryGlueTableCredentials) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetTemporaryGlueTableCredentials) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetTemporaryGlueTableCredentialsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetTemporaryGlueTableCredentials")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetTemporaryGlueTableCredentialsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetTemporaryGlueTableCredentialsInput(v *GetTemporaryGlueTableCredentialsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetTemporaryGlueTableCredentialsInput(v *GetTemporaryGlueTableCredentialsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AuditContext != nil {
ok := object.Key("AuditContext")
if err := awsRestjson1_serializeDocumentAuditContext(v.AuditContext, ok); err != nil {
return err
}
}
if v.DurationSeconds != nil {
ok := object.Key("DurationSeconds")
ok.Integer(*v.DurationSeconds)
}
if v.Permissions != nil {
ok := object.Key("Permissions")
if err := awsRestjson1_serializeDocumentPermissionList(v.Permissions, ok); err != nil {
return err
}
}
if v.SupportedPermissionTypes != nil {
ok := object.Key("SupportedPermissionTypes")
if err := awsRestjson1_serializeDocumentPermissionTypeList(v.SupportedPermissionTypes, ok); err != nil {
return err
}
}
if v.TableArn != nil {
ok := object.Key("TableArn")
ok.String(*v.TableArn)
}
return nil
}
type awsRestjson1_serializeOpGetWorkUnitResults struct {
}
func (*awsRestjson1_serializeOpGetWorkUnitResults) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWorkUnitResults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetWorkUnitResultsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetWorkUnitResults")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetWorkUnitResultsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetWorkUnitResultsInput(v *GetWorkUnitResultsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetWorkUnitResultsInput(v *GetWorkUnitResultsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.QueryId != nil {
ok := object.Key("QueryId")
ok.String(*v.QueryId)
}
{
ok := object.Key("WorkUnitId")
ok.Long(v.WorkUnitId)
}
if v.WorkUnitToken != nil {
ok := object.Key("WorkUnitToken")
ok.String(*v.WorkUnitToken)
}
return nil
}
type awsRestjson1_serializeOpGetWorkUnits struct {
}
func (*awsRestjson1_serializeOpGetWorkUnits) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWorkUnits) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetWorkUnitsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetWorkUnits")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetWorkUnitsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetWorkUnitsInput(v *GetWorkUnitsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetWorkUnitsInput(v *GetWorkUnitsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.PageSize != nil {
ok := object.Key("PageSize")
ok.Integer(*v.PageSize)
}
if v.QueryId != nil {
ok := object.Key("QueryId")
ok.String(*v.QueryId)
}
return nil
}
type awsRestjson1_serializeOpGrantPermissions struct {
}
func (*awsRestjson1_serializeOpGrantPermissions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGrantPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GrantPermissionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GrantPermissions")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGrantPermissionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGrantPermissionsInput(v *GrantPermissionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGrantPermissionsInput(v *GrantPermissionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Permissions != nil {
ok := object.Key("Permissions")
if err := awsRestjson1_serializeDocumentPermissionList(v.Permissions, ok); err != nil {
return err
}
}
if v.PermissionsWithGrantOption != nil {
ok := object.Key("PermissionsWithGrantOption")
if err := awsRestjson1_serializeDocumentPermissionList(v.PermissionsWithGrantOption, ok); err != nil {
return err
}
}
if v.Principal != nil {
ok := object.Key("Principal")
if err := awsRestjson1_serializeDocumentDataLakePrincipal(v.Principal, ok); err != nil {
return err
}
}
if v.Resource != nil {
ok := object.Key("Resource")
if err := awsRestjson1_serializeDocumentResource(v.Resource, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListDataCellsFilter struct {
}
func (*awsRestjson1_serializeOpListDataCellsFilter) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListDataCellsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListDataCellsFilterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ListDataCellsFilter")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListDataCellsFilterInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListDataCellsFilterInput(v *ListDataCellsFilterInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListDataCellsFilterInput(v *ListDataCellsFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.Table != nil {
ok := object.Key("Table")
if err := awsRestjson1_serializeDocumentTableResource(v.Table, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListLFTags struct {
}
func (*awsRestjson1_serializeOpListLFTags) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListLFTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListLFTagsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ListLFTags")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListLFTagsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListLFTagsInput(v *ListLFTagsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListLFTagsInput(v *ListLFTagsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if len(v.ResourceShareType) > 0 {
ok := object.Key("ResourceShareType")
ok.String(string(v.ResourceShareType))
}
return nil
}
type awsRestjson1_serializeOpListPermissions struct {
}
func (*awsRestjson1_serializeOpListPermissions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListPermissionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ListPermissions")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListPermissionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListPermissionsInput(v *ListPermissionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListPermissionsInput(v *ListPermissionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.IncludeRelated != nil {
ok := object.Key("IncludeRelated")
ok.String(*v.IncludeRelated)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.Principal != nil {
ok := object.Key("Principal")
if err := awsRestjson1_serializeDocumentDataLakePrincipal(v.Principal, ok); err != nil {
return err
}
}
if v.Resource != nil {
ok := object.Key("Resource")
if err := awsRestjson1_serializeDocumentResource(v.Resource, ok); err != nil {
return err
}
}
if len(v.ResourceType) > 0 {
ok := object.Key("ResourceType")
ok.String(string(v.ResourceType))
}
return nil
}
type awsRestjson1_serializeOpListResources struct {
}
func (*awsRestjson1_serializeOpListResources) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListResources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListResourcesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ListResources")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListResourcesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListResourcesInput(v *ListResourcesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListResourcesInput(v *ListResourcesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FilterConditionList != nil {
ok := object.Key("FilterConditionList")
if err := awsRestjson1_serializeDocumentFilterConditionList(v.FilterConditionList, ok); err != nil {
return err
}
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListTableStorageOptimizers struct {
}
func (*awsRestjson1_serializeOpListTableStorageOptimizers) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListTableStorageOptimizers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListTableStorageOptimizersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ListTableStorageOptimizers")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListTableStorageOptimizersInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListTableStorageOptimizersInput(v *ListTableStorageOptimizersInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListTableStorageOptimizersInput(v *ListTableStorageOptimizersInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if len(v.StorageOptimizerType) > 0 {
ok := object.Key("StorageOptimizerType")
ok.String(string(v.StorageOptimizerType))
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
return nil
}
type awsRestjson1_serializeOpListTransactions struct {
}
func (*awsRestjson1_serializeOpListTransactions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListTransactions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListTransactionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ListTransactions")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListTransactionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListTransactionsInput(v *ListTransactionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListTransactionsInput(v *ListTransactionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if len(v.StatusFilter) > 0 {
ok := object.Key("StatusFilter")
ok.String(string(v.StatusFilter))
}
return nil
}
type awsRestjson1_serializeOpPutDataLakeSettings struct {
}
func (*awsRestjson1_serializeOpPutDataLakeSettings) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutDataLakeSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*PutDataLakeSettingsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/PutDataLakeSettings")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentPutDataLakeSettingsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsPutDataLakeSettingsInput(v *PutDataLakeSettingsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentPutDataLakeSettingsInput(v *PutDataLakeSettingsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.DataLakeSettings != nil {
ok := object.Key("DataLakeSettings")
if err := awsRestjson1_serializeDocumentDataLakeSettings(v.DataLakeSettings, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpRegisterResource struct {
}
func (*awsRestjson1_serializeOpRegisterResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpRegisterResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*RegisterResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/RegisterResource")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentRegisterResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsRegisterResourceInput(v *RegisterResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentRegisterResourceInput(v *RegisterResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
if v.RoleArn != nil {
ok := object.Key("RoleArn")
ok.String(*v.RoleArn)
}
if v.UseServiceLinkedRole != nil {
ok := object.Key("UseServiceLinkedRole")
ok.Boolean(*v.UseServiceLinkedRole)
}
if v.WithFederation != nil {
ok := object.Key("WithFederation")
ok.Boolean(*v.WithFederation)
}
return nil
}
type awsRestjson1_serializeOpRemoveLFTagsFromResource struct {
}
func (*awsRestjson1_serializeOpRemoveLFTagsFromResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpRemoveLFTagsFromResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*RemoveLFTagsFromResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/RemoveLFTagsFromResource")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentRemoveLFTagsFromResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsRemoveLFTagsFromResourceInput(v *RemoveLFTagsFromResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentRemoveLFTagsFromResourceInput(v *RemoveLFTagsFromResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.LFTags != nil {
ok := object.Key("LFTags")
if err := awsRestjson1_serializeDocumentLFTagsList(v.LFTags, ok); err != nil {
return err
}
}
if v.Resource != nil {
ok := object.Key("Resource")
if err := awsRestjson1_serializeDocumentResource(v.Resource, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpRevokePermissions struct {
}
func (*awsRestjson1_serializeOpRevokePermissions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpRevokePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*RevokePermissionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/RevokePermissions")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentRevokePermissionsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsRevokePermissionsInput(v *RevokePermissionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentRevokePermissionsInput(v *RevokePermissionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Permissions != nil {
ok := object.Key("Permissions")
if err := awsRestjson1_serializeDocumentPermissionList(v.Permissions, ok); err != nil {
return err
}
}
if v.PermissionsWithGrantOption != nil {
ok := object.Key("PermissionsWithGrantOption")
if err := awsRestjson1_serializeDocumentPermissionList(v.PermissionsWithGrantOption, ok); err != nil {
return err
}
}
if v.Principal != nil {
ok := object.Key("Principal")
if err := awsRestjson1_serializeDocumentDataLakePrincipal(v.Principal, ok); err != nil {
return err
}
}
if v.Resource != nil {
ok := object.Key("Resource")
if err := awsRestjson1_serializeDocumentResource(v.Resource, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpSearchDatabasesByLFTags struct {
}
func (*awsRestjson1_serializeOpSearchDatabasesByLFTags) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpSearchDatabasesByLFTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*SearchDatabasesByLFTagsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/SearchDatabasesByLFTags")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentSearchDatabasesByLFTagsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsSearchDatabasesByLFTagsInput(v *SearchDatabasesByLFTagsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentSearchDatabasesByLFTagsInput(v *SearchDatabasesByLFTagsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Expression != nil {
ok := object.Key("Expression")
if err := awsRestjson1_serializeDocumentExpression(v.Expression, ok); err != nil {
return err
}
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpSearchTablesByLFTags struct {
}
func (*awsRestjson1_serializeOpSearchTablesByLFTags) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpSearchTablesByLFTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*SearchTablesByLFTagsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/SearchTablesByLFTags")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentSearchTablesByLFTagsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsSearchTablesByLFTagsInput(v *SearchTablesByLFTagsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentSearchTablesByLFTagsInput(v *SearchTablesByLFTagsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Expression != nil {
ok := object.Key("Expression")
if err := awsRestjson1_serializeDocumentExpression(v.Expression, ok); err != nil {
return err
}
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpStartQueryPlanning struct {
}
func (*awsRestjson1_serializeOpStartQueryPlanning) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartQueryPlanning) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StartQueryPlanningInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/StartQueryPlanning")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartQueryPlanningInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartQueryPlanningInput(v *StartQueryPlanningInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartQueryPlanningInput(v *StartQueryPlanningInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.QueryPlanningContext != nil {
ok := object.Key("QueryPlanningContext")
if err := awsRestjson1_serializeDocumentQueryPlanningContext(v.QueryPlanningContext, ok); err != nil {
return err
}
}
if v.QueryString != nil {
ok := object.Key("QueryString")
ok.String(*v.QueryString)
}
return nil
}
type awsRestjson1_serializeOpStartTransaction struct {
}
func (*awsRestjson1_serializeOpStartTransaction) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartTransaction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StartTransactionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/StartTransaction")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartTransactionInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartTransactionInput(v *StartTransactionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartTransactionInput(v *StartTransactionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.TransactionType) > 0 {
ok := object.Key("TransactionType")
ok.String(string(v.TransactionType))
}
return nil
}
type awsRestjson1_serializeOpUpdateDataCellsFilter struct {
}
func (*awsRestjson1_serializeOpUpdateDataCellsFilter) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateDataCellsFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateDataCellsFilterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/UpdateDataCellsFilter")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateDataCellsFilterInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateDataCellsFilterInput(v *UpdateDataCellsFilterInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateDataCellsFilterInput(v *UpdateDataCellsFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TableData != nil {
ok := object.Key("TableData")
if err := awsRestjson1_serializeDocumentDataCellsFilter(v.TableData, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateLFTag struct {
}
func (*awsRestjson1_serializeOpUpdateLFTag) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateLFTag) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateLFTagInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/UpdateLFTag")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateLFTagInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateLFTagInput(v *UpdateLFTagInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateLFTagInput(v *UpdateLFTagInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.TagKey != nil {
ok := object.Key("TagKey")
ok.String(*v.TagKey)
}
if v.TagValuesToAdd != nil {
ok := object.Key("TagValuesToAdd")
if err := awsRestjson1_serializeDocumentTagValueList(v.TagValuesToAdd, ok); err != nil {
return err
}
}
if v.TagValuesToDelete != nil {
ok := object.Key("TagValuesToDelete")
if err := awsRestjson1_serializeDocumentTagValueList(v.TagValuesToDelete, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateResource struct {
}
func (*awsRestjson1_serializeOpUpdateResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/UpdateResource")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateResourceInput(v *UpdateResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateResourceInput(v *UpdateResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
if v.RoleArn != nil {
ok := object.Key("RoleArn")
ok.String(*v.RoleArn)
}
if v.WithFederation != nil {
ok := object.Key("WithFederation")
ok.Boolean(*v.WithFederation)
}
return nil
}
type awsRestjson1_serializeOpUpdateTableObjects struct {
}
func (*awsRestjson1_serializeOpUpdateTableObjects) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateTableObjects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateTableObjectsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/UpdateTableObjects")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateTableObjectsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateTableObjectsInput(v *UpdateTableObjectsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateTableObjectsInput(v *UpdateTableObjectsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
if v.TransactionId != nil {
ok := object.Key("TransactionId")
ok.String(*v.TransactionId)
}
if v.WriteOperations != nil {
ok := object.Key("WriteOperations")
if err := awsRestjson1_serializeDocumentWriteOperationList(v.WriteOperations, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateTableStorageOptimizer struct {
}
func (*awsRestjson1_serializeOpUpdateTableStorageOptimizer) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateTableStorageOptimizer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateTableStorageOptimizerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/UpdateTableStorageOptimizer")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateTableStorageOptimizerInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateTableStorageOptimizerInput(v *UpdateTableStorageOptimizerInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateTableStorageOptimizerInput(v *UpdateTableStorageOptimizerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.StorageOptimizerConfig != nil {
ok := object.Key("StorageOptimizerConfig")
if err := awsRestjson1_serializeDocumentStorageOptimizerConfigMap(v.StorageOptimizerConfig, ok); err != nil {
return err
}
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
return nil
}
func awsRestjson1_serializeDocumentAddObjectInput(v *types.AddObjectInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ETag != nil {
ok := object.Key("ETag")
ok.String(*v.ETag)
}
if v.PartitionValues != nil {
ok := object.Key("PartitionValues")
if err := awsRestjson1_serializeDocumentPartitionValuesList(v.PartitionValues, ok); err != nil {
return err
}
}
{
ok := object.Key("Size")
ok.Long(v.Size)
}
if v.Uri != nil {
ok := object.Key("Uri")
ok.String(*v.Uri)
}
return nil
}
func awsRestjson1_serializeDocumentAllRowsWildcard(v *types.AllRowsWildcard, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsRestjson1_serializeDocumentAuditContext(v *types.AuditContext, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdditionalAuditContext != nil {
ok := object.Key("AdditionalAuditContext")
ok.String(*v.AdditionalAuditContext)
}
return nil
}
func awsRestjson1_serializeDocumentAuthorizedSessionTagValueList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentBatchPermissionsRequestEntry(v *types.BatchPermissionsRequestEntry, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Id != nil {
ok := object.Key("Id")
ok.String(*v.Id)
}
if v.Permissions != nil {
ok := object.Key("Permissions")
if err := awsRestjson1_serializeDocumentPermissionList(v.Permissions, ok); err != nil {
return err
}
}
if v.PermissionsWithGrantOption != nil {
ok := object.Key("PermissionsWithGrantOption")
if err := awsRestjson1_serializeDocumentPermissionList(v.PermissionsWithGrantOption, ok); err != nil {
return err
}
}
if v.Principal != nil {
ok := object.Key("Principal")
if err := awsRestjson1_serializeDocumentDataLakePrincipal(v.Principal, ok); err != nil {
return err
}
}
if v.Resource != nil {
ok := object.Key("Resource")
if err := awsRestjson1_serializeDocumentResource(v.Resource, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentBatchPermissionsRequestEntryList(v []types.BatchPermissionsRequestEntry, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentBatchPermissionsRequestEntry(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCatalogResource(v *types.CatalogResource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsRestjson1_serializeDocumentColumnNames(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentColumnWildcard(v *types.ColumnWildcard, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ExcludedColumnNames != nil {
ok := object.Key("ExcludedColumnNames")
if err := awsRestjson1_serializeDocumentColumnNames(v.ExcludedColumnNames, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDatabaseResource(v *types.DatabaseResource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
func awsRestjson1_serializeDocumentDataCellsFilter(v *types.DataCellsFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ColumnNames != nil {
ok := object.Key("ColumnNames")
if err := awsRestjson1_serializeDocumentColumnNames(v.ColumnNames, ok); err != nil {
return err
}
}
if v.ColumnWildcard != nil {
ok := object.Key("ColumnWildcard")
if err := awsRestjson1_serializeDocumentColumnWildcard(v.ColumnWildcard, ok); err != nil {
return err
}
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.RowFilter != nil {
ok := object.Key("RowFilter")
if err := awsRestjson1_serializeDocumentRowFilter(v.RowFilter, ok); err != nil {
return err
}
}
if v.TableCatalogId != nil {
ok := object.Key("TableCatalogId")
ok.String(*v.TableCatalogId)
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
if v.VersionId != nil {
ok := object.Key("VersionId")
ok.String(*v.VersionId)
}
return nil
}
func awsRestjson1_serializeDocumentDataCellsFilterResource(v *types.DataCellsFilterResource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.TableCatalogId != nil {
ok := object.Key("TableCatalogId")
ok.String(*v.TableCatalogId)
}
if v.TableName != nil {
ok := object.Key("TableName")
ok.String(*v.TableName)
}
return nil
}
func awsRestjson1_serializeDocumentDataLakePrincipal(v *types.DataLakePrincipal, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DataLakePrincipalIdentifier != nil {
ok := object.Key("DataLakePrincipalIdentifier")
ok.String(*v.DataLakePrincipalIdentifier)
}
return nil
}
func awsRestjson1_serializeDocumentDataLakePrincipalList(v []types.DataLakePrincipal, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentDataLakePrincipal(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDataLakeSettings(v *types.DataLakeSettings, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AllowExternalDataFiltering != nil {
ok := object.Key("AllowExternalDataFiltering")
ok.Boolean(*v.AllowExternalDataFiltering)
}
if v.AuthorizedSessionTagValueList != nil {
ok := object.Key("AuthorizedSessionTagValueList")
if err := awsRestjson1_serializeDocumentAuthorizedSessionTagValueList(v.AuthorizedSessionTagValueList, ok); err != nil {
return err
}
}
if v.CreateDatabaseDefaultPermissions != nil {
ok := object.Key("CreateDatabaseDefaultPermissions")
if err := awsRestjson1_serializeDocumentPrincipalPermissionsList(v.CreateDatabaseDefaultPermissions, ok); err != nil {
return err
}
}
if v.CreateTableDefaultPermissions != nil {
ok := object.Key("CreateTableDefaultPermissions")
if err := awsRestjson1_serializeDocumentPrincipalPermissionsList(v.CreateTableDefaultPermissions, ok); err != nil {
return err
}
}
if v.DataLakeAdmins != nil {
ok := object.Key("DataLakeAdmins")
if err := awsRestjson1_serializeDocumentDataLakePrincipalList(v.DataLakeAdmins, ok); err != nil {
return err
}
}
if v.ExternalDataFilteringAllowList != nil {
ok := object.Key("ExternalDataFilteringAllowList")
if err := awsRestjson1_serializeDocumentDataLakePrincipalList(v.ExternalDataFilteringAllowList, ok); err != nil {
return err
}
}
if v.Parameters != nil {
ok := object.Key("Parameters")
if err := awsRestjson1_serializeDocumentParametersMap(v.Parameters, ok); err != nil {
return err
}
}
if v.TrustedResourceOwners != nil {
ok := object.Key("TrustedResourceOwners")
if err := awsRestjson1_serializeDocumentTrustedResourceOwners(v.TrustedResourceOwners, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDataLocationResource(v *types.DataLocationResource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
return nil
}
func awsRestjson1_serializeDocumentDeleteObjectInput(v *types.DeleteObjectInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ETag != nil {
ok := object.Key("ETag")
ok.String(*v.ETag)
}
if v.PartitionValues != nil {
ok := object.Key("PartitionValues")
if err := awsRestjson1_serializeDocumentPartitionValuesList(v.PartitionValues, ok); err != nil {
return err
}
}
if v.Uri != nil {
ok := object.Key("Uri")
ok.String(*v.Uri)
}
return nil
}
func awsRestjson1_serializeDocumentExpression(v []types.LFTag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentLFTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentFilterCondition(v *types.FilterCondition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ComparisonOperator) > 0 {
ok := object.Key("ComparisonOperator")
ok.String(string(v.ComparisonOperator))
}
if len(v.Field) > 0 {
ok := object.Key("Field")
ok.String(string(v.Field))
}
if v.StringValueList != nil {
ok := object.Key("StringValueList")
if err := awsRestjson1_serializeDocumentStringValueList(v.StringValueList, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentFilterConditionList(v []types.FilterCondition, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentFilterCondition(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLFTag(v *types.LFTag, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TagKey != nil {
ok := object.Key("TagKey")
ok.String(*v.TagKey)
}
if v.TagValues != nil {
ok := object.Key("TagValues")
if err := awsRestjson1_serializeDocumentTagValueList(v.TagValues, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLFTagKeyResource(v *types.LFTagKeyResource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.TagKey != nil {
ok := object.Key("TagKey")
ok.String(*v.TagKey)
}
if v.TagValues != nil {
ok := object.Key("TagValues")
if err := awsRestjson1_serializeDocumentTagValueList(v.TagValues, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLFTagPair(v *types.LFTagPair, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.TagKey != nil {
ok := object.Key("TagKey")
ok.String(*v.TagKey)
}
if v.TagValues != nil {
ok := object.Key("TagValues")
if err := awsRestjson1_serializeDocumentTagValueList(v.TagValues, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLFTagPolicyResource(v *types.LFTagPolicyResource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.Expression != nil {
ok := object.Key("Expression")
if err := awsRestjson1_serializeDocumentExpression(v.Expression, ok); err != nil {
return err
}
}
if len(v.ResourceType) > 0 {
ok := object.Key("ResourceType")
ok.String(string(v.ResourceType))
}
return nil
}
func awsRestjson1_serializeDocumentLFTagsList(v []types.LFTagPair, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentLFTagPair(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentParametersMap(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentPartitionValueList(v *types.PartitionValueList, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Values != nil {
ok := object.Key("Values")
if err := awsRestjson1_serializeDocumentValueStringList(v.Values, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPartitionValuesList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentPermissionList(v []types.Permission, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsRestjson1_serializeDocumentPermissionTypeList(v []types.PermissionType, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsRestjson1_serializeDocumentPrincipalPermissions(v *types.PrincipalPermissions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Permissions != nil {
ok := object.Key("Permissions")
if err := awsRestjson1_serializeDocumentPermissionList(v.Permissions, ok); err != nil {
return err
}
}
if v.Principal != nil {
ok := object.Key("Principal")
if err := awsRestjson1_serializeDocumentDataLakePrincipal(v.Principal, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPrincipalPermissionsList(v []types.PrincipalPermissions, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentPrincipalPermissions(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentQueryParameterMap(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentQueryPlanningContext(v *types.QueryPlanningContext, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.QueryAsOfTime != nil {
ok := object.Key("QueryAsOfTime")
ok.Double(smithytime.FormatEpochSeconds(*v.QueryAsOfTime))
}
if v.QueryParameters != nil {
ok := object.Key("QueryParameters")
if err := awsRestjson1_serializeDocumentQueryParameterMap(v.QueryParameters, ok); err != nil {
return err
}
}
if v.TransactionId != nil {
ok := object.Key("TransactionId")
ok.String(*v.TransactionId)
}
return nil
}
func awsRestjson1_serializeDocumentResource(v *types.Resource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Catalog != nil {
ok := object.Key("Catalog")
if err := awsRestjson1_serializeDocumentCatalogResource(v.Catalog, ok); err != nil {
return err
}
}
if v.Database != nil {
ok := object.Key("Database")
if err := awsRestjson1_serializeDocumentDatabaseResource(v.Database, ok); err != nil {
return err
}
}
if v.DataCellsFilter != nil {
ok := object.Key("DataCellsFilter")
if err := awsRestjson1_serializeDocumentDataCellsFilterResource(v.DataCellsFilter, ok); err != nil {
return err
}
}
if v.DataLocation != nil {
ok := object.Key("DataLocation")
if err := awsRestjson1_serializeDocumentDataLocationResource(v.DataLocation, ok); err != nil {
return err
}
}
if v.LFTag != nil {
ok := object.Key("LFTag")
if err := awsRestjson1_serializeDocumentLFTagKeyResource(v.LFTag, ok); err != nil {
return err
}
}
if v.LFTagPolicy != nil {
ok := object.Key("LFTagPolicy")
if err := awsRestjson1_serializeDocumentLFTagPolicyResource(v.LFTagPolicy, ok); err != nil {
return err
}
}
if v.Table != nil {
ok := object.Key("Table")
if err := awsRestjson1_serializeDocumentTableResource(v.Table, ok); err != nil {
return err
}
}
if v.TableWithColumns != nil {
ok := object.Key("TableWithColumns")
if err := awsRestjson1_serializeDocumentTableWithColumnsResource(v.TableWithColumns, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentRowFilter(v *types.RowFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AllRowsWildcard != nil {
ok := object.Key("AllRowsWildcard")
if err := awsRestjson1_serializeDocumentAllRowsWildcard(v.AllRowsWildcard, ok); err != nil {
return err
}
}
if v.FilterExpression != nil {
ok := object.Key("FilterExpression")
ok.String(*v.FilterExpression)
}
return nil
}
func awsRestjson1_serializeDocumentStorageOptimizerConfig(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentStorageOptimizerConfigMap(v map[string]map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
if vv := v[key]; vv == nil {
continue
}
if err := awsRestjson1_serializeDocumentStorageOptimizerConfig(v[key], om); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentStringValueList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentTableResource(v *types.TableResource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.TableWildcard != nil {
ok := object.Key("TableWildcard")
if err := awsRestjson1_serializeDocumentTableWildcard(v.TableWildcard, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTableWildcard(v *types.TableWildcard, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsRestjson1_serializeDocumentTableWithColumnsResource(v *types.TableWithColumnsResource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CatalogId != nil {
ok := object.Key("CatalogId")
ok.String(*v.CatalogId)
}
if v.ColumnNames != nil {
ok := object.Key("ColumnNames")
if err := awsRestjson1_serializeDocumentColumnNames(v.ColumnNames, ok); err != nil {
return err
}
}
if v.ColumnWildcard != nil {
ok := object.Key("ColumnWildcard")
if err := awsRestjson1_serializeDocumentColumnWildcard(v.ColumnWildcard, ok); err != nil {
return err
}
}
if v.DatabaseName != nil {
ok := object.Key("DatabaseName")
ok.String(*v.DatabaseName)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
func awsRestjson1_serializeDocumentTagValueList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentTrustedResourceOwners(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentValueStringList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentVirtualObject(v *types.VirtualObject, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ETag != nil {
ok := object.Key("ETag")
ok.String(*v.ETag)
}
if v.Uri != nil {
ok := object.Key("Uri")
ok.String(*v.Uri)
}
return nil
}
func awsRestjson1_serializeDocumentVirtualObjectList(v []types.VirtualObject, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentVirtualObject(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWriteOperation(v *types.WriteOperation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AddObject != nil {
ok := object.Key("AddObject")
if err := awsRestjson1_serializeDocumentAddObjectInput(v.AddObject, ok); err != nil {
return err
}
}
if v.DeleteObject != nil {
ok := object.Key("DeleteObject")
if err := awsRestjson1_serializeDocumentDeleteObjectInput(v.DeleteObject, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWriteOperationList(v []types.WriteOperation, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentWriteOperation(&v[i], av); err != nil {
return err
}
}
return nil
}
| 4,737 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lakeformation
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/lakeformation/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpAddLFTagsToResource struct {
}
func (*validateOpAddLFTagsToResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAddLFTagsToResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AddLFTagsToResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAddLFTagsToResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssumeDecoratedRoleWithSAML struct {
}
func (*validateOpAssumeDecoratedRoleWithSAML) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssumeDecoratedRoleWithSAML) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssumeDecoratedRoleWithSAMLInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssumeDecoratedRoleWithSAMLInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchGrantPermissions struct {
}
func (*validateOpBatchGrantPermissions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchGrantPermissions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchGrantPermissionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchGrantPermissionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchRevokePermissions struct {
}
func (*validateOpBatchRevokePermissions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchRevokePermissions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchRevokePermissionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchRevokePermissionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelTransaction struct {
}
func (*validateOpCancelTransaction) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelTransaction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelTransactionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelTransactionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCommitTransaction struct {
}
func (*validateOpCommitTransaction) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCommitTransaction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CommitTransactionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCommitTransactionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateDataCellsFilter struct {
}
func (*validateOpCreateDataCellsFilter) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateDataCellsFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateDataCellsFilterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateDataCellsFilterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateLFTag struct {
}
func (*validateOpCreateLFTag) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateLFTag) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateLFTagInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateLFTagInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteLFTag struct {
}
func (*validateOpDeleteLFTag) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteLFTag) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteLFTagInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteLFTagInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteObjectsOnCancel struct {
}
func (*validateOpDeleteObjectsOnCancel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteObjectsOnCancel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteObjectsOnCancelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteObjectsOnCancelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeregisterResource struct {
}
func (*validateOpDeregisterResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeregisterResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeregisterResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeregisterResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeResource struct {
}
func (*validateOpDescribeResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeTransaction struct {
}
func (*validateOpDescribeTransaction) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeTransaction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeTransactionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeTransactionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetDataCellsFilter struct {
}
func (*validateOpGetDataCellsFilter) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetDataCellsFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetDataCellsFilterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetDataCellsFilterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetEffectivePermissionsForPath struct {
}
func (*validateOpGetEffectivePermissionsForPath) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetEffectivePermissionsForPath) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetEffectivePermissionsForPathInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetEffectivePermissionsForPathInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetLFTag struct {
}
func (*validateOpGetLFTag) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetLFTag) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetLFTagInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetLFTagInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetQueryState struct {
}
func (*validateOpGetQueryState) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetQueryState) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetQueryStateInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetQueryStateInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetQueryStatistics struct {
}
func (*validateOpGetQueryStatistics) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetQueryStatistics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetQueryStatisticsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetQueryStatisticsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetResourceLFTags struct {
}
func (*validateOpGetResourceLFTags) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetResourceLFTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetResourceLFTagsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetResourceLFTagsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetTableObjects struct {
}
func (*validateOpGetTableObjects) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetTableObjects) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetTableObjectsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetTableObjectsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetTemporaryGluePartitionCredentials struct {
}
func (*validateOpGetTemporaryGluePartitionCredentials) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetTemporaryGluePartitionCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetTemporaryGluePartitionCredentialsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetTemporaryGluePartitionCredentialsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetTemporaryGlueTableCredentials struct {
}
func (*validateOpGetTemporaryGlueTableCredentials) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetTemporaryGlueTableCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetTemporaryGlueTableCredentialsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetTemporaryGlueTableCredentialsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWorkUnitResults struct {
}
func (*validateOpGetWorkUnitResults) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWorkUnitResults) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWorkUnitResultsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWorkUnitResultsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWorkUnits struct {
}
func (*validateOpGetWorkUnits) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWorkUnits) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWorkUnitsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWorkUnitsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGrantPermissions struct {
}
func (*validateOpGrantPermissions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGrantPermissions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GrantPermissionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGrantPermissionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListDataCellsFilter struct {
}
func (*validateOpListDataCellsFilter) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListDataCellsFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListDataCellsFilterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListDataCellsFilterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListPermissions struct {
}
func (*validateOpListPermissions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListPermissions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListPermissionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListPermissionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListTableStorageOptimizers struct {
}
func (*validateOpListTableStorageOptimizers) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListTableStorageOptimizers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListTableStorageOptimizersInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListTableStorageOptimizersInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutDataLakeSettings struct {
}
func (*validateOpPutDataLakeSettings) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutDataLakeSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutDataLakeSettingsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutDataLakeSettingsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRegisterResource struct {
}
func (*validateOpRegisterResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRegisterResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RegisterResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRegisterResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRemoveLFTagsFromResource struct {
}
func (*validateOpRemoveLFTagsFromResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRemoveLFTagsFromResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RemoveLFTagsFromResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRemoveLFTagsFromResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRevokePermissions struct {
}
func (*validateOpRevokePermissions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRevokePermissions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RevokePermissionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRevokePermissionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSearchDatabasesByLFTags struct {
}
func (*validateOpSearchDatabasesByLFTags) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSearchDatabasesByLFTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SearchDatabasesByLFTagsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSearchDatabasesByLFTagsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSearchTablesByLFTags struct {
}
func (*validateOpSearchTablesByLFTags) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSearchTablesByLFTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SearchTablesByLFTagsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSearchTablesByLFTagsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartQueryPlanning struct {
}
func (*validateOpStartQueryPlanning) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartQueryPlanning) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartQueryPlanningInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartQueryPlanningInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateDataCellsFilter struct {
}
func (*validateOpUpdateDataCellsFilter) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateDataCellsFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateDataCellsFilterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateDataCellsFilterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateLFTag struct {
}
func (*validateOpUpdateLFTag) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateLFTag) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateLFTagInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateLFTagInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateResource struct {
}
func (*validateOpUpdateResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateTableObjects struct {
}
func (*validateOpUpdateTableObjects) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateTableObjects) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateTableObjectsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateTableObjectsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateTableStorageOptimizer struct {
}
func (*validateOpUpdateTableStorageOptimizer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateTableStorageOptimizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateTableStorageOptimizerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateTableStorageOptimizerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpAddLFTagsToResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAddLFTagsToResource{}, middleware.After)
}
func addOpAssumeDecoratedRoleWithSAMLValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssumeDecoratedRoleWithSAML{}, middleware.After)
}
func addOpBatchGrantPermissionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchGrantPermissions{}, middleware.After)
}
func addOpBatchRevokePermissionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchRevokePermissions{}, middleware.After)
}
func addOpCancelTransactionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelTransaction{}, middleware.After)
}
func addOpCommitTransactionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCommitTransaction{}, middleware.After)
}
func addOpCreateDataCellsFilterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateDataCellsFilter{}, middleware.After)
}
func addOpCreateLFTagValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateLFTag{}, middleware.After)
}
func addOpDeleteLFTagValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteLFTag{}, middleware.After)
}
func addOpDeleteObjectsOnCancelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteObjectsOnCancel{}, middleware.After)
}
func addOpDeregisterResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeregisterResource{}, middleware.After)
}
func addOpDescribeResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeResource{}, middleware.After)
}
func addOpDescribeTransactionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeTransaction{}, middleware.After)
}
func addOpGetDataCellsFilterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetDataCellsFilter{}, middleware.After)
}
func addOpGetEffectivePermissionsForPathValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetEffectivePermissionsForPath{}, middleware.After)
}
func addOpGetLFTagValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetLFTag{}, middleware.After)
}
func addOpGetQueryStateValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetQueryState{}, middleware.After)
}
func addOpGetQueryStatisticsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetQueryStatistics{}, middleware.After)
}
func addOpGetResourceLFTagsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetResourceLFTags{}, middleware.After)
}
func addOpGetTableObjectsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetTableObjects{}, middleware.After)
}
func addOpGetTemporaryGluePartitionCredentialsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetTemporaryGluePartitionCredentials{}, middleware.After)
}
func addOpGetTemporaryGlueTableCredentialsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetTemporaryGlueTableCredentials{}, middleware.After)
}
func addOpGetWorkUnitResultsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWorkUnitResults{}, middleware.After)
}
func addOpGetWorkUnitsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWorkUnits{}, middleware.After)
}
func addOpGrantPermissionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGrantPermissions{}, middleware.After)
}
func addOpListDataCellsFilterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListDataCellsFilter{}, middleware.After)
}
func addOpListPermissionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListPermissions{}, middleware.After)
}
func addOpListTableStorageOptimizersValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTableStorageOptimizers{}, middleware.After)
}
func addOpPutDataLakeSettingsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutDataLakeSettings{}, middleware.After)
}
func addOpRegisterResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRegisterResource{}, middleware.After)
}
func addOpRemoveLFTagsFromResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRemoveLFTagsFromResource{}, middleware.After)
}
func addOpRevokePermissionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRevokePermissions{}, middleware.After)
}
func addOpSearchDatabasesByLFTagsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSearchDatabasesByLFTags{}, middleware.After)
}
func addOpSearchTablesByLFTagsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSearchTablesByLFTags{}, middleware.After)
}
func addOpStartQueryPlanningValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartQueryPlanning{}, middleware.After)
}
func addOpUpdateDataCellsFilterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateDataCellsFilter{}, middleware.After)
}
func addOpUpdateLFTagValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateLFTag{}, middleware.After)
}
func addOpUpdateResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateResource{}, middleware.After)
}
func addOpUpdateTableObjectsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateTableObjects{}, middleware.After)
}
func addOpUpdateTableStorageOptimizerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateTableStorageOptimizer{}, middleware.After)
}
func validateAddObjectInput(v *types.AddObjectInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AddObjectInput"}
if v.Uri == nil {
invalidParams.Add(smithy.NewErrParamRequired("Uri"))
}
if v.ETag == nil {
invalidParams.Add(smithy.NewErrParamRequired("ETag"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateBatchPermissionsRequestEntry(v *types.BatchPermissionsRequestEntry) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchPermissionsRequestEntry"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.Resource != nil {
if err := validateResource(v.Resource); err != nil {
invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateBatchPermissionsRequestEntryList(v []types.BatchPermissionsRequestEntry) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchPermissionsRequestEntryList"}
for i := range v {
if err := validateBatchPermissionsRequestEntry(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDatabaseResource(v *types.DatabaseResource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DatabaseResource"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDataCellsFilter(v *types.DataCellsFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DataCellsFilter"}
if v.TableCatalogId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableCatalogId"))
}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDataLocationResource(v *types.DataLocationResource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DataLocationResource"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDeleteObjectInput(v *types.DeleteObjectInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteObjectInput"}
if v.Uri == nil {
invalidParams.Add(smithy.NewErrParamRequired("Uri"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateExpression(v []types.LFTag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Expression"}
for i := range v {
if err := validateLFTag(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLFTag(v *types.LFTag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LFTag"}
if v.TagKey == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
}
if v.TagValues == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagValues"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLFTagKeyResource(v *types.LFTagKeyResource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LFTagKeyResource"}
if v.TagKey == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
}
if v.TagValues == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagValues"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLFTagPair(v *types.LFTagPair) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LFTagPair"}
if v.TagKey == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
}
if v.TagValues == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagValues"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLFTagPolicyResource(v *types.LFTagPolicyResource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LFTagPolicyResource"}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if v.Expression == nil {
invalidParams.Add(smithy.NewErrParamRequired("Expression"))
} else if v.Expression != nil {
if err := validateExpression(v.Expression); err != nil {
invalidParams.AddNested("Expression", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLFTagsList(v []types.LFTagPair) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LFTagsList"}
for i := range v {
if err := validateLFTagPair(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePartitionValueList(v *types.PartitionValueList) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PartitionValueList"}
if v.Values == nil {
invalidParams.Add(smithy.NewErrParamRequired("Values"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateQueryPlanningContext(v *types.QueryPlanningContext) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "QueryPlanningContext"}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResource(v *types.Resource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Resource"}
if v.Database != nil {
if err := validateDatabaseResource(v.Database); err != nil {
invalidParams.AddNested("Database", err.(smithy.InvalidParamsError))
}
}
if v.Table != nil {
if err := validateTableResource(v.Table); err != nil {
invalidParams.AddNested("Table", err.(smithy.InvalidParamsError))
}
}
if v.TableWithColumns != nil {
if err := validateTableWithColumnsResource(v.TableWithColumns); err != nil {
invalidParams.AddNested("TableWithColumns", err.(smithy.InvalidParamsError))
}
}
if v.DataLocation != nil {
if err := validateDataLocationResource(v.DataLocation); err != nil {
invalidParams.AddNested("DataLocation", err.(smithy.InvalidParamsError))
}
}
if v.LFTag != nil {
if err := validateLFTagKeyResource(v.LFTag); err != nil {
invalidParams.AddNested("LFTag", err.(smithy.InvalidParamsError))
}
}
if v.LFTagPolicy != nil {
if err := validateLFTagPolicyResource(v.LFTagPolicy); err != nil {
invalidParams.AddNested("LFTagPolicy", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTableResource(v *types.TableResource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TableResource"}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTableWithColumnsResource(v *types.TableWithColumnsResource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TableWithColumnsResource"}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVirtualObject(v *types.VirtualObject) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VirtualObject"}
if v.Uri == nil {
invalidParams.Add(smithy.NewErrParamRequired("Uri"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVirtualObjectList(v []types.VirtualObject) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VirtualObjectList"}
for i := range v {
if err := validateVirtualObject(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWriteOperation(v *types.WriteOperation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WriteOperation"}
if v.AddObject != nil {
if err := validateAddObjectInput(v.AddObject); err != nil {
invalidParams.AddNested("AddObject", err.(smithy.InvalidParamsError))
}
}
if v.DeleteObject != nil {
if err := validateDeleteObjectInput(v.DeleteObject); err != nil {
invalidParams.AddNested("DeleteObject", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWriteOperationList(v []types.WriteOperation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WriteOperationList"}
for i := range v {
if err := validateWriteOperation(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAddLFTagsToResourceInput(v *AddLFTagsToResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AddLFTagsToResourceInput"}
if v.Resource == nil {
invalidParams.Add(smithy.NewErrParamRequired("Resource"))
} else if v.Resource != nil {
if err := validateResource(v.Resource); err != nil {
invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
}
}
if v.LFTags == nil {
invalidParams.Add(smithy.NewErrParamRequired("LFTags"))
} else if v.LFTags != nil {
if err := validateLFTagsList(v.LFTags); err != nil {
invalidParams.AddNested("LFTags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssumeDecoratedRoleWithSAMLInput(v *AssumeDecoratedRoleWithSAMLInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssumeDecoratedRoleWithSAMLInput"}
if v.SAMLAssertion == nil {
invalidParams.Add(smithy.NewErrParamRequired("SAMLAssertion"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.PrincipalArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrincipalArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchGrantPermissionsInput(v *BatchGrantPermissionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchGrantPermissionsInput"}
if v.Entries == nil {
invalidParams.Add(smithy.NewErrParamRequired("Entries"))
} else if v.Entries != nil {
if err := validateBatchPermissionsRequestEntryList(v.Entries); err != nil {
invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchRevokePermissionsInput(v *BatchRevokePermissionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchRevokePermissionsInput"}
if v.Entries == nil {
invalidParams.Add(smithy.NewErrParamRequired("Entries"))
} else if v.Entries != nil {
if err := validateBatchPermissionsRequestEntryList(v.Entries); err != nil {
invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelTransactionInput(v *CancelTransactionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelTransactionInput"}
if v.TransactionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransactionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCommitTransactionInput(v *CommitTransactionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CommitTransactionInput"}
if v.TransactionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransactionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateDataCellsFilterInput(v *CreateDataCellsFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateDataCellsFilterInput"}
if v.TableData == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableData"))
} else if v.TableData != nil {
if err := validateDataCellsFilter(v.TableData); err != nil {
invalidParams.AddNested("TableData", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateLFTagInput(v *CreateLFTagInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateLFTagInput"}
if v.TagKey == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
}
if v.TagValues == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagValues"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteLFTagInput(v *DeleteLFTagInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteLFTagInput"}
if v.TagKey == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteObjectsOnCancelInput(v *DeleteObjectsOnCancelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteObjectsOnCancelInput"}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if v.TransactionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransactionId"))
}
if v.Objects == nil {
invalidParams.Add(smithy.NewErrParamRequired("Objects"))
} else if v.Objects != nil {
if err := validateVirtualObjectList(v.Objects); err != nil {
invalidParams.AddNested("Objects", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeregisterResourceInput(v *DeregisterResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeregisterResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeResourceInput(v *DescribeResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeTransactionInput(v *DescribeTransactionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeTransactionInput"}
if v.TransactionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransactionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetDataCellsFilterInput(v *GetDataCellsFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetDataCellsFilterInput"}
if v.TableCatalogId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableCatalogId"))
}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetEffectivePermissionsForPathInput(v *GetEffectivePermissionsForPathInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetEffectivePermissionsForPathInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetLFTagInput(v *GetLFTagInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetLFTagInput"}
if v.TagKey == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetQueryStateInput(v *GetQueryStateInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetQueryStateInput"}
if v.QueryId == nil {
invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetQueryStatisticsInput(v *GetQueryStatisticsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetQueryStatisticsInput"}
if v.QueryId == nil {
invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetResourceLFTagsInput(v *GetResourceLFTagsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetResourceLFTagsInput"}
if v.Resource == nil {
invalidParams.Add(smithy.NewErrParamRequired("Resource"))
} else if v.Resource != nil {
if err := validateResource(v.Resource); err != nil {
invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetTableObjectsInput(v *GetTableObjectsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetTableObjectsInput"}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetTemporaryGluePartitionCredentialsInput(v *GetTemporaryGluePartitionCredentialsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetTemporaryGluePartitionCredentialsInput"}
if v.TableArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableArn"))
}
if v.Partition == nil {
invalidParams.Add(smithy.NewErrParamRequired("Partition"))
} else if v.Partition != nil {
if err := validatePartitionValueList(v.Partition); err != nil {
invalidParams.AddNested("Partition", err.(smithy.InvalidParamsError))
}
}
if v.SupportedPermissionTypes == nil {
invalidParams.Add(smithy.NewErrParamRequired("SupportedPermissionTypes"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetTemporaryGlueTableCredentialsInput(v *GetTemporaryGlueTableCredentialsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetTemporaryGlueTableCredentialsInput"}
if v.TableArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableArn"))
}
if v.SupportedPermissionTypes == nil {
invalidParams.Add(smithy.NewErrParamRequired("SupportedPermissionTypes"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWorkUnitResultsInput(v *GetWorkUnitResultsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWorkUnitResultsInput"}
if v.QueryId == nil {
invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
}
if v.WorkUnitToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("WorkUnitToken"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWorkUnitsInput(v *GetWorkUnitsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWorkUnitsInput"}
if v.QueryId == nil {
invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGrantPermissionsInput(v *GrantPermissionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GrantPermissionsInput"}
if v.Principal == nil {
invalidParams.Add(smithy.NewErrParamRequired("Principal"))
}
if v.Resource == nil {
invalidParams.Add(smithy.NewErrParamRequired("Resource"))
} else if v.Resource != nil {
if err := validateResource(v.Resource); err != nil {
invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
}
}
if v.Permissions == nil {
invalidParams.Add(smithy.NewErrParamRequired("Permissions"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListDataCellsFilterInput(v *ListDataCellsFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListDataCellsFilterInput"}
if v.Table != nil {
if err := validateTableResource(v.Table); err != nil {
invalidParams.AddNested("Table", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListPermissionsInput(v *ListPermissionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListPermissionsInput"}
if v.Resource != nil {
if err := validateResource(v.Resource); err != nil {
invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListTableStorageOptimizersInput(v *ListTableStorageOptimizersInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListTableStorageOptimizersInput"}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutDataLakeSettingsInput(v *PutDataLakeSettingsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutDataLakeSettingsInput"}
if v.DataLakeSettings == nil {
invalidParams.Add(smithy.NewErrParamRequired("DataLakeSettings"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRegisterResourceInput(v *RegisterResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RegisterResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRemoveLFTagsFromResourceInput(v *RemoveLFTagsFromResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RemoveLFTagsFromResourceInput"}
if v.Resource == nil {
invalidParams.Add(smithy.NewErrParamRequired("Resource"))
} else if v.Resource != nil {
if err := validateResource(v.Resource); err != nil {
invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
}
}
if v.LFTags == nil {
invalidParams.Add(smithy.NewErrParamRequired("LFTags"))
} else if v.LFTags != nil {
if err := validateLFTagsList(v.LFTags); err != nil {
invalidParams.AddNested("LFTags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRevokePermissionsInput(v *RevokePermissionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RevokePermissionsInput"}
if v.Principal == nil {
invalidParams.Add(smithy.NewErrParamRequired("Principal"))
}
if v.Resource == nil {
invalidParams.Add(smithy.NewErrParamRequired("Resource"))
} else if v.Resource != nil {
if err := validateResource(v.Resource); err != nil {
invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
}
}
if v.Permissions == nil {
invalidParams.Add(smithy.NewErrParamRequired("Permissions"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSearchDatabasesByLFTagsInput(v *SearchDatabasesByLFTagsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SearchDatabasesByLFTagsInput"}
if v.Expression == nil {
invalidParams.Add(smithy.NewErrParamRequired("Expression"))
} else if v.Expression != nil {
if err := validateExpression(v.Expression); err != nil {
invalidParams.AddNested("Expression", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSearchTablesByLFTagsInput(v *SearchTablesByLFTagsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SearchTablesByLFTagsInput"}
if v.Expression == nil {
invalidParams.Add(smithy.NewErrParamRequired("Expression"))
} else if v.Expression != nil {
if err := validateExpression(v.Expression); err != nil {
invalidParams.AddNested("Expression", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartQueryPlanningInput(v *StartQueryPlanningInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartQueryPlanningInput"}
if v.QueryPlanningContext == nil {
invalidParams.Add(smithy.NewErrParamRequired("QueryPlanningContext"))
} else if v.QueryPlanningContext != nil {
if err := validateQueryPlanningContext(v.QueryPlanningContext); err != nil {
invalidParams.AddNested("QueryPlanningContext", err.(smithy.InvalidParamsError))
}
}
if v.QueryString == nil {
invalidParams.Add(smithy.NewErrParamRequired("QueryString"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateDataCellsFilterInput(v *UpdateDataCellsFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateDataCellsFilterInput"}
if v.TableData == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableData"))
} else if v.TableData != nil {
if err := validateDataCellsFilter(v.TableData); err != nil {
invalidParams.AddNested("TableData", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateLFTagInput(v *UpdateLFTagInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateLFTagInput"}
if v.TagKey == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateResourceInput(v *UpdateResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceInput"}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateTableObjectsInput(v *UpdateTableObjectsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateTableObjectsInput"}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if v.WriteOperations == nil {
invalidParams.Add(smithy.NewErrParamRequired("WriteOperations"))
} else if v.WriteOperations != nil {
if err := validateWriteOperationList(v.WriteOperations); err != nil {
invalidParams.AddNested("WriteOperations", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateTableStorageOptimizerInput(v *UpdateTableStorageOptimizerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateTableStorageOptimizerInput"}
if v.DatabaseName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if v.StorageOptimizerConfig == nil {
invalidParams.Add(smithy.NewErrParamRequired("StorageOptimizerConfig"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 2,135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver LakeFormation endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "lakeformation.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "lakeformation-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "lakeformation.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "af-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "fips-us-east-1",
}: endpoints.Endpoint{
Hostname: "lakeformation-fips.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-east-2",
}: endpoints.Endpoint{
Hostname: "lakeformation-fips.us-east-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-west-1",
}: endpoints.Endpoint{
Hostname: "lakeformation-fips.us-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-west-2",
}: endpoints.Endpoint{
Hostname: "lakeformation-fips.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "me-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "me-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "sa-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.us-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.us-east-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.us-west-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.us-west-2.amazonaws.com",
},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "lakeformation.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "lakeformation-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "lakeformation.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "cn-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "cn-northwest-1",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "lakeformation.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "lakeformation.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "lakeformation.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "lakeformation.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "lakeformation.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "lakeformation-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "lakeformation.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "fips-us-gov-east-1",
}: endpoints.Endpoint{
Hostname: "lakeformation-fips.us-gov-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-gov-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-gov-west-1",
}: endpoints.Endpoint{
Hostname: "lakeformation-fips.us-gov-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-gov-west-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-gov-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.us-gov-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-gov-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "lakeformation-fips.us-gov-west-1.amazonaws.com",
},
},
},
}
| 480 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type ComparisonOperator string
// Enum values for ComparisonOperator
const (
ComparisonOperatorEq ComparisonOperator = "EQ"
ComparisonOperatorNe ComparisonOperator = "NE"
ComparisonOperatorLe ComparisonOperator = "LE"
ComparisonOperatorLt ComparisonOperator = "LT"
ComparisonOperatorGe ComparisonOperator = "GE"
ComparisonOperatorGt ComparisonOperator = "GT"
ComparisonOperatorContains ComparisonOperator = "CONTAINS"
ComparisonOperatorNotContains ComparisonOperator = "NOT_CONTAINS"
ComparisonOperatorBeginsWith ComparisonOperator = "BEGINS_WITH"
ComparisonOperatorIn ComparisonOperator = "IN"
ComparisonOperatorBetween ComparisonOperator = "BETWEEN"
)
// Values returns all known values for ComparisonOperator. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ComparisonOperator) Values() []ComparisonOperator {
return []ComparisonOperator{
"EQ",
"NE",
"LE",
"LT",
"GE",
"GT",
"CONTAINS",
"NOT_CONTAINS",
"BEGINS_WITH",
"IN",
"BETWEEN",
}
}
type DataLakeResourceType string
// Enum values for DataLakeResourceType
const (
DataLakeResourceTypeCatalog DataLakeResourceType = "CATALOG"
DataLakeResourceTypeDatabase DataLakeResourceType = "DATABASE"
DataLakeResourceTypeTable DataLakeResourceType = "TABLE"
DataLakeResourceTypeDataLocation DataLakeResourceType = "DATA_LOCATION"
DataLakeResourceTypeLfTag DataLakeResourceType = "LF_TAG"
DataLakeResourceTypeLfTagPolicy DataLakeResourceType = "LF_TAG_POLICY"
DataLakeResourceTypeLfTagPolicyDatabase DataLakeResourceType = "LF_TAG_POLICY_DATABASE"
DataLakeResourceTypeLfTagPolicyTable DataLakeResourceType = "LF_TAG_POLICY_TABLE"
)
// Values returns all known values for DataLakeResourceType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (DataLakeResourceType) Values() []DataLakeResourceType {
return []DataLakeResourceType{
"CATALOG",
"DATABASE",
"TABLE",
"DATA_LOCATION",
"LF_TAG",
"LF_TAG_POLICY",
"LF_TAG_POLICY_DATABASE",
"LF_TAG_POLICY_TABLE",
}
}
type FieldNameString string
// Enum values for FieldNameString
const (
FieldNameStringResourceArn FieldNameString = "RESOURCE_ARN"
FieldNameStringRoleArn FieldNameString = "ROLE_ARN"
FieldNameStringLastModified FieldNameString = "LAST_MODIFIED"
)
// Values returns all known values for FieldNameString. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (FieldNameString) Values() []FieldNameString {
return []FieldNameString{
"RESOURCE_ARN",
"ROLE_ARN",
"LAST_MODIFIED",
}
}
type OptimizerType string
// Enum values for OptimizerType
const (
OptimizerTypeCompaction OptimizerType = "COMPACTION"
OptimizerTypeGarbageCollection OptimizerType = "GARBAGE_COLLECTION"
OptimizerTypeGeneric OptimizerType = "ALL"
)
// Values returns all known values for OptimizerType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (OptimizerType) Values() []OptimizerType {
return []OptimizerType{
"COMPACTION",
"GARBAGE_COLLECTION",
"ALL",
}
}
type Permission string
// Enum values for Permission
const (
PermissionAll Permission = "ALL"
PermissionSelect Permission = "SELECT"
PermissionAlter Permission = "ALTER"
PermissionDrop Permission = "DROP"
PermissionDelete Permission = "DELETE"
PermissionInsert Permission = "INSERT"
PermissionDescribe Permission = "DESCRIBE"
PermissionCreateDatabase Permission = "CREATE_DATABASE"
PermissionCreateTable Permission = "CREATE_TABLE"
PermissionDataLocationAccess Permission = "DATA_LOCATION_ACCESS"
PermissionCreateTag Permission = "CREATE_TAG"
PermissionAssociate Permission = "ASSOCIATE"
)
// Values returns all known values for Permission. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (Permission) Values() []Permission {
return []Permission{
"ALL",
"SELECT",
"ALTER",
"DROP",
"DELETE",
"INSERT",
"DESCRIBE",
"CREATE_DATABASE",
"CREATE_TABLE",
"DATA_LOCATION_ACCESS",
"CREATE_TAG",
"ASSOCIATE",
}
}
type PermissionType string
// Enum values for PermissionType
const (
PermissionTypeColumnPermission PermissionType = "COLUMN_PERMISSION"
PermissionTypeCellFilterPermission PermissionType = "CELL_FILTER_PERMISSION"
)
// Values returns all known values for PermissionType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (PermissionType) Values() []PermissionType {
return []PermissionType{
"COLUMN_PERMISSION",
"CELL_FILTER_PERMISSION",
}
}
type QueryStateString string
// Enum values for QueryStateString
const (
QueryStateStringPending QueryStateString = "PENDING"
QueryStateStringWorkunitsAvailable QueryStateString = "WORKUNITS_AVAILABLE"
QueryStateStringError QueryStateString = "ERROR"
QueryStateStringFinished QueryStateString = "FINISHED"
QueryStateStringExpired QueryStateString = "EXPIRED"
)
// Values returns all known values for QueryStateString. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (QueryStateString) Values() []QueryStateString {
return []QueryStateString{
"PENDING",
"WORKUNITS_AVAILABLE",
"ERROR",
"FINISHED",
"EXPIRED",
}
}
type ResourceShareType string
// Enum values for ResourceShareType
const (
ResourceShareTypeForeign ResourceShareType = "FOREIGN"
ResourceShareTypeAll ResourceShareType = "ALL"
)
// Values returns all known values for ResourceShareType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ResourceShareType) Values() []ResourceShareType {
return []ResourceShareType{
"FOREIGN",
"ALL",
}
}
type ResourceType string
// Enum values for ResourceType
const (
ResourceTypeDatabase ResourceType = "DATABASE"
ResourceTypeTable ResourceType = "TABLE"
)
// Values returns all known values for ResourceType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ResourceType) Values() []ResourceType {
return []ResourceType{
"DATABASE",
"TABLE",
}
}
type TransactionStatus string
// Enum values for TransactionStatus
const (
TransactionStatusActive TransactionStatus = "ACTIVE"
TransactionStatusCommitted TransactionStatus = "COMMITTED"
TransactionStatusAborted TransactionStatus = "ABORTED"
TransactionStatusCommitInProgress TransactionStatus = "COMMIT_IN_PROGRESS"
)
// Values returns all known values for TransactionStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TransactionStatus) Values() []TransactionStatus {
return []TransactionStatus{
"ACTIVE",
"COMMITTED",
"ABORTED",
"COMMIT_IN_PROGRESS",
}
}
type TransactionStatusFilter string
// Enum values for TransactionStatusFilter
const (
TransactionStatusFilterAll TransactionStatusFilter = "ALL"
TransactionStatusFilterCompleted TransactionStatusFilter = "COMPLETED"
TransactionStatusFilterActive TransactionStatusFilter = "ACTIVE"
TransactionStatusFilterCommitted TransactionStatusFilter = "COMMITTED"
TransactionStatusFilterAborted TransactionStatusFilter = "ABORTED"
)
// Values returns all known values for TransactionStatusFilter. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TransactionStatusFilter) Values() []TransactionStatusFilter {
return []TransactionStatusFilter{
"ALL",
"COMPLETED",
"ACTIVE",
"COMMITTED",
"ABORTED",
}
}
type TransactionType string
// Enum values for TransactionType
const (
TransactionTypeReadAndWrite TransactionType = "READ_AND_WRITE"
TransactionTypeReadOnly TransactionType = "READ_ONLY"
)
// Values returns all known values for TransactionType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TransactionType) Values() []TransactionType {
return []TransactionType{
"READ_AND_WRITE",
"READ_ONLY",
}
}
| 290 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// Access to a resource was denied.
type AccessDeniedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *AccessDeniedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *AccessDeniedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *AccessDeniedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "AccessDeniedException"
}
return *e.ErrorCodeOverride
}
func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// A resource to be created or added already exists.
type AlreadyExistsException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *AlreadyExistsException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *AlreadyExistsException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *AlreadyExistsException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "AlreadyExistsException"
}
return *e.ErrorCodeOverride
}
func (e *AlreadyExistsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Two processes are trying to modify a resource simultaneously.
type ConcurrentModificationException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ConcurrentModificationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ConcurrentModificationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ConcurrentModificationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ConcurrentModificationException"
}
return *e.ErrorCodeOverride
}
func (e *ConcurrentModificationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// A specified entity does not exist.
type EntityNotFoundException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *EntityNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *EntityNotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *EntityNotFoundException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "EntityNotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *EntityNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Contains details about an error where the query request expired.
type ExpiredException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ExpiredException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ExpiredException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ExpiredException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ExpiredException"
}
return *e.ErrorCodeOverride
}
func (e *ExpiredException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// An encryption operation failed.
type GlueEncryptionException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *GlueEncryptionException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *GlueEncryptionException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *GlueEncryptionException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "GlueEncryptionException"
}
return *e.ErrorCodeOverride
}
func (e *GlueEncryptionException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// An internal service error occurred.
type InternalServiceException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalServiceException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServiceException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServiceException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServiceException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServiceException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The input provided was not valid.
type InvalidInputException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidInputException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidInputException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidInputException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidInputException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidInputException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The operation timed out.
type OperationTimeoutException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *OperationTimeoutException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *OperationTimeoutException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *OperationTimeoutException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "OperationTimeoutException"
}
return *e.ErrorCodeOverride
}
func (e *OperationTimeoutException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The engine does not support filtering data based on the enforced permissions.
// For example, if you call the GetTemporaryGlueTableCredentials operation with
// SupportedPermissionType equal to ColumnPermission , but cell-level permissions
// exist on the table, this exception is thrown.
type PermissionTypeMismatchException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *PermissionTypeMismatchException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *PermissionTypeMismatchException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *PermissionTypeMismatchException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "PermissionTypeMismatchException"
}
return *e.ErrorCodeOverride
}
func (e *PermissionTypeMismatchException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Contains details about an error related to a resource which is not ready for a
// transaction.
type ResourceNotReadyException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ResourceNotReadyException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotReadyException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotReadyException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotReadyException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotReadyException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// A resource numerical limit was exceeded.
type ResourceNumberLimitExceededException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ResourceNumberLimitExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNumberLimitExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNumberLimitExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNumberLimitExceededException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNumberLimitExceededException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
// Contains details about an error related to statistics not being ready.
type StatisticsNotReadyYetException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *StatisticsNotReadyYetException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *StatisticsNotReadyYetException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *StatisticsNotReadyYetException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "StatisticsNotReadyYetException"
}
return *e.ErrorCodeOverride
}
func (e *StatisticsNotReadyYetException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Contains details about an error where the query request was throttled.
type ThrottledException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ThrottledException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ThrottledException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ThrottledException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ThrottledException"
}
return *e.ErrorCodeOverride
}
func (e *ThrottledException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Contains details about an error related to a transaction that was cancelled.
type TransactionCanceledException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *TransactionCanceledException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TransactionCanceledException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TransactionCanceledException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TransactionCanceledException"
}
return *e.ErrorCodeOverride
}
func (e *TransactionCanceledException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Contains details about an error related to a transaction commit that was in
// progress.
type TransactionCommitInProgressException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *TransactionCommitInProgressException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TransactionCommitInProgressException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TransactionCommitInProgressException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TransactionCommitInProgressException"
}
return *e.ErrorCodeOverride
}
func (e *TransactionCommitInProgressException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
// Contains details about an error where the specified transaction has already
// been committed and cannot be used for UpdateTableObjects .
type TransactionCommittedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *TransactionCommittedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TransactionCommittedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TransactionCommittedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TransactionCommittedException"
}
return *e.ErrorCodeOverride
}
func (e *TransactionCommittedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Contains details about an error related to work units not being ready.
type WorkUnitsNotReadyYetException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *WorkUnitsNotReadyYetException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *WorkUnitsNotReadyYetException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *WorkUnitsNotReadyYetException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "WorkUnitsNotReadyYetException"
}
return *e.ErrorCodeOverride
}
func (e *WorkUnitsNotReadyYetException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 487 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
"time"
)
// A new object to add to the governed table.
type AddObjectInput struct {
// The Amazon S3 ETag of the object. Returned by GetTableObjects for validation
// and used to identify changes to the underlying data.
//
// This member is required.
ETag *string
// The size of the Amazon S3 object in bytes.
//
// This member is required.
Size int64
// The Amazon S3 location of the object.
//
// This member is required.
Uri *string
// A list of partition values for the object. A value must be specified for each
// partition key associated with the table. The supported data types are integer,
// long, date(yyyy-MM-dd), timestamp(yyyy-MM-dd HH:mm:ssXXX or yyyy-MM-dd
// HH:mm:ss"), string and decimal.
PartitionValues []string
noSmithyDocumentSerde
}
// A structure that you pass to indicate you want all rows in a filter.
type AllRowsWildcard struct {
noSmithyDocumentSerde
}
// A structure used to include auditing information on the privileged API.
type AuditContext struct {
// The filter engine can populate the 'AdditionalAuditContext' information with
// the request ID for you to track. This information will be displayed in
// CloudTrail log in your account.
AdditionalAuditContext *string
noSmithyDocumentSerde
}
// A list of failures when performing a batch grant or batch revoke operation.
type BatchPermissionsFailureEntry struct {
// An error message that applies to the failure of the entry.
Error *ErrorDetail
// An identifier for an entry of the batch request.
RequestEntry *BatchPermissionsRequestEntry
noSmithyDocumentSerde
}
// A permission to a resource granted by batch operation to the principal.
type BatchPermissionsRequestEntry struct {
// A unique identifier for the batch permissions request entry.
//
// This member is required.
Id *string
// The permissions to be granted.
Permissions []Permission
// Indicates if the option to pass permissions is granted.
PermissionsWithGrantOption []Permission
// The principal to be granted a permission.
Principal *DataLakePrincipal
// The resource to which the principal is to be granted a permission.
Resource *Resource
noSmithyDocumentSerde
}
// A structure for the catalog object.
type CatalogResource struct {
noSmithyDocumentSerde
}
// A structure containing the name of a column resource and the LF-tags attached
// to it.
type ColumnLFTag struct {
// The LF-tags attached to a column resource.
LFTags []LFTagPair
// The name of a column resource.
Name *string
noSmithyDocumentSerde
}
// A wildcard object, consisting of an optional list of excluded column names or
// indexes.
type ColumnWildcard struct {
// Excludes column names. Any column with this name will be excluded.
ExcludedColumnNames []string
noSmithyDocumentSerde
}
// A structure for the database object.
type DatabaseResource struct {
// The name of the database resource. Unique to the Data Catalog.
//
// This member is required.
Name *string
// The identifier for the Data Catalog. By default, it is the account ID of the
// caller.
CatalogId *string
noSmithyDocumentSerde
}
// A structure that describes certain columns on certain rows.
type DataCellsFilter struct {
// A database in the Glue Data Catalog.
//
// This member is required.
DatabaseName *string
// The name given by the user to the data filter cell.
//
// This member is required.
Name *string
// The ID of the catalog to which the table belongs.
//
// This member is required.
TableCatalogId *string
// A table in the database.
//
// This member is required.
TableName *string
// A list of column names.
ColumnNames []string
// A wildcard with exclusions. You must specify either a ColumnNames list or the
// ColumnWildCard .
ColumnWildcard *ColumnWildcard
// A PartiQL predicate.
RowFilter *RowFilter
// The ID of the data cells filter version.
VersionId *string
noSmithyDocumentSerde
}
// A structure for a data cells filter resource.
type DataCellsFilterResource struct {
// A database in the Glue Data Catalog.
DatabaseName *string
// The name of the data cells filter.
Name *string
// The ID of the catalog to which the table belongs.
TableCatalogId *string
// The name of the table.
TableName *string
noSmithyDocumentSerde
}
// The Lake Formation principal. Supported principals are IAM users or IAM roles.
type DataLakePrincipal struct {
// An identifier for the Lake Formation principal.
DataLakePrincipalIdentifier *string
noSmithyDocumentSerde
}
// A structure representing a list of Lake Formation principals designated as data
// lake administrators and lists of principal permission entries for default create
// database and default create table permissions.
type DataLakeSettings struct {
// Whether to allow Amazon EMR clusters to access data managed by Lake Formation.
// If true, you allow Amazon EMR clusters to access data in Amazon S3 locations
// that are registered with Lake Formation. If false or null, no Amazon EMR
// clusters will be able to access data in Amazon S3 locations that are registered
// with Lake Formation. For more information, see (Optional) Allow Data Filtering
// on Amazon EMR (https://docs-aws.amazon.com/lake-formation/latest/dg/getting-started-setup.html#emr-switch)
// .
AllowExternalDataFiltering *bool
// Lake Formation relies on a privileged process secured by Amazon EMR or the
// third party integrator to tag the user's role while assuming it. Lake Formation
// will publish the acceptable key-value pair, for example key =
// "LakeFormationTrustedCaller" and value = "TRUE" and the third party integrator
// must properly tag the temporary security credentials that will be used to call
// Lake Formation's administrative APIs.
AuthorizedSessionTagValueList []string
// Specifies whether access control on newly created database is managed by Lake
// Formation permissions or exclusively by IAM permissions. A null value indicates
// access control by Lake Formation permissions. A value that assigns ALL to
// IAM_ALLOWED_PRINCIPALS indicates access control by IAM permissions. This is
// referred to as the setting "Use only IAM access control," and is for backward
// compatibility with the Glue permission model implemented by IAM permissions. The
// only permitted values are an empty array or an array that contains a single JSON
// object that grants ALL to IAM_ALLOWED_PRINCIPALS. For more information, see
// Changing the Default Security Settings for Your Data Lake (https://docs.aws.amazon.com/lake-formation/latest/dg/change-settings.html)
// .
CreateDatabaseDefaultPermissions []PrincipalPermissions
// Specifies whether access control on newly created table is managed by Lake
// Formation permissions or exclusively by IAM permissions. A null value indicates
// access control by Lake Formation permissions. A value that assigns ALL to
// IAM_ALLOWED_PRINCIPALS indicates access control by IAM permissions. This is
// referred to as the setting "Use only IAM access control," and is for backward
// compatibility with the Glue permission model implemented by IAM permissions. The
// only permitted values are an empty array or an array that contains a single JSON
// object that grants ALL to IAM_ALLOWED_PRINCIPALS. For more information, see
// Changing the Default Security Settings for Your Data Lake (https://docs.aws.amazon.com/lake-formation/latest/dg/change-settings.html)
// .
CreateTableDefaultPermissions []PrincipalPermissions
// A list of Lake Formation principals. Supported principals are IAM users or IAM
// roles.
DataLakeAdmins []DataLakePrincipal
// A list of the account IDs of Amazon Web Services accounts with Amazon EMR
// clusters that are to perform data filtering.>
ExternalDataFilteringAllowList []DataLakePrincipal
// A key-value map that provides an additional configuration on your data lake.
// CrossAccountVersion is the key you can configure in the Parameters field.
// Accepted values for the CrossAccountVersion key are 1, 2, and 3.
Parameters map[string]string
// A list of the resource-owning account IDs that the caller's account can use to
// share their user access details (user ARNs). The user ARNs can be logged in the
// resource owner's CloudTrail log. You may want to specify this property when you
// are in a high-trust boundary, such as the same team or company.
TrustedResourceOwners []string
noSmithyDocumentSerde
}
// A structure for a data location object where permissions are granted or revoked.
type DataLocationResource struct {
// The Amazon Resource Name (ARN) that uniquely identifies the data location
// resource.
//
// This member is required.
ResourceArn *string
// The identifier for the Data Catalog where the location is registered with Lake
// Formation. By default, it is the account ID of the caller.
CatalogId *string
noSmithyDocumentSerde
}
// An object to delete from the governed table.
type DeleteObjectInput struct {
// The Amazon S3 location of the object to delete.
//
// This member is required.
Uri *string
// The Amazon S3 ETag of the object. Returned by GetTableObjects for validation
// and used to identify changes to the underlying data.
ETag *string
// A list of partition values for the object. A value must be specified for each
// partition key associated with the governed table.
PartitionValues []string
noSmithyDocumentSerde
}
// A structure containing the additional details to be returned in the
// AdditionalDetails attribute of PrincipalResourcePermissions . If a catalog
// resource is shared through Resource Access Manager (RAM), then there will exist
// a corresponding RAM resource share ARN.
type DetailsMap struct {
// A resource share ARN for a catalog resource shared through RAM.
ResourceShare []string
noSmithyDocumentSerde
}
// Contains details about an error.
type ErrorDetail struct {
// The code associated with this error.
ErrorCode *string
// A message describing the error.
ErrorMessage *string
noSmithyDocumentSerde
}
// Statistics related to the processing of a query statement.
type ExecutionStatistics struct {
// The average time the request took to be executed.
AverageExecutionTimeMillis int64
// The amount of data that was scanned in bytes.
DataScannedBytes int64
// The number of work units executed.
WorkUnitsExecutedCount int64
noSmithyDocumentSerde
}
// This structure describes the filtering of columns in a table based on a filter
// condition.
type FilterCondition struct {
// The comparison operator used in the filter condition.
ComparisonOperator ComparisonOperator
// The field to filter in the filter condition.
Field FieldNameString
// A string with values used in evaluating the filter condition.
StringValueList []string
noSmithyDocumentSerde
}
// A structure that allows an admin to grant user permissions on certain
// conditions. For example, granting a role access to all columns that do not have
// the LF-tag 'PII' in tables that have the LF-tag 'Prod'.
type LFTag struct {
// The key-name for the LF-tag.
//
// This member is required.
TagKey *string
// A list of possible values an attribute can take.
//
// This member is required.
TagValues []string
noSmithyDocumentSerde
}
// A structure containing an error related to a TagResource or UnTagResource
// operation.
type LFTagError struct {
// An error that occurred with the attachment or detachment of the LF-tag.
Error *ErrorDetail
// The key-name of the LF-tag.
LFTag *LFTagPair
noSmithyDocumentSerde
}
// A structure containing an LF-tag key and values for a resource.
type LFTagKeyResource struct {
// The key-name for the LF-tag.
//
// This member is required.
TagKey *string
// A list of possible values an attribute can take.
//
// This member is required.
TagValues []string
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
// A structure containing an LF-tag key-value pair.
type LFTagPair struct {
// The key-name for the LF-tag.
//
// This member is required.
TagKey *string
// A list of possible values an attribute can take.
//
// This member is required.
TagValues []string
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
// A structure containing a list of LF-tag conditions that apply to a resource's
// LF-tag policy.
type LFTagPolicyResource struct {
// A list of LF-tag conditions that apply to the resource's LF-tag policy.
//
// This member is required.
Expression []LFTag
// The resource type for which the LF-tag policy applies.
//
// This member is required.
ResourceType ResourceType
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
CatalogId *string
noSmithyDocumentSerde
}
// A structure containing a list of partition values and table objects.
type PartitionObjects struct {
// A list of table objects
Objects []TableObject
// A list of partition values.
PartitionValues []string
noSmithyDocumentSerde
}
// Contains a list of values defining partitions.
type PartitionValueList struct {
// The list of partition values.
//
// This member is required.
Values []string
noSmithyDocumentSerde
}
// Statistics related to the processing of a query statement.
type PlanningStatistics struct {
// An estimate of the data that was scanned in bytes.
EstimatedDataToScanBytes int64
// The time that it took to process the request.
PlanningTimeMillis int64
// The time the request was in queue to be processed.
QueueTimeMillis int64
// The number of work units generated.
WorkUnitsGeneratedCount int64
noSmithyDocumentSerde
}
// Permissions granted to a principal.
type PrincipalPermissions struct {
// The permissions that are granted to the principal.
Permissions []Permission
// The principal who is granted permissions.
Principal *DataLakePrincipal
noSmithyDocumentSerde
}
// The permissions granted or revoked on a resource.
type PrincipalResourcePermissions struct {
// This attribute can be used to return any additional details of
// PrincipalResourcePermissions . Currently returns only as a RAM resource share
// ARN.
AdditionalDetails *DetailsMap
// The permissions to be granted or revoked on the resource.
Permissions []Permission
// Indicates whether to grant the ability to grant permissions (as a subset of
// permissions granted).
PermissionsWithGrantOption []Permission
// The Data Lake principal to be granted or revoked permissions.
Principal *DataLakePrincipal
// The resource where permissions are to be granted or revoked.
Resource *Resource
noSmithyDocumentSerde
}
// A structure containing information about the query plan.
type QueryPlanningContext struct {
// The database containing the table.
//
// This member is required.
DatabaseName *string
// The ID of the Data Catalog where the partition in question resides. If none is
// provided, the Amazon Web Services account ID is used by default.
CatalogId *string
// The time as of when to read the table contents. If not set, the most recent
// transaction commit time will be used. Cannot be specified along with
// TransactionId .
QueryAsOfTime *time.Time
// A map consisting of key-value pairs.
QueryParameters map[string]string
// The transaction ID at which to read the table contents. If this transaction is
// not committed, the read will be treated as part of that transaction and will see
// its writes. If this transaction has aborted, an error will be returned. If not
// set, defaults to the most recent committed transaction. Cannot be specified
// along with QueryAsOfTime .
TransactionId *string
noSmithyDocumentSerde
}
// A structure for the resource.
type Resource struct {
// The identifier for the Data Catalog. By default, the account ID. The Data
// Catalog is the persistent metadata store. It contains database definitions,
// table definitions, and other control information to manage your Lake Formation
// environment.
Catalog *CatalogResource
// A data cell filter.
DataCellsFilter *DataCellsFilterResource
// The location of an Amazon S3 path where permissions are granted or revoked.
DataLocation *DataLocationResource
// The database for the resource. Unique to the Data Catalog. A database is a set
// of associated table definitions organized into a logical group. You can Grant
// and Revoke database permissions to a principal.
Database *DatabaseResource
// The LF-tag key and values attached to a resource.
LFTag *LFTagKeyResource
// A list of LF-tag conditions that define a resource's LF-tag policy.
LFTagPolicy *LFTagPolicyResource
// The table for the resource. A table is a metadata definition that represents
// your data. You can Grant and Revoke table privileges to a principal.
Table *TableResource
// The table with columns for the resource. A principal with permissions to this
// resource can select metadata from the columns of a table in the Data Catalog and
// the underlying data in Amazon S3.
TableWithColumns *TableWithColumnsResource
noSmithyDocumentSerde
}
// A structure containing information about an Lake Formation resource.
type ResourceInfo struct {
// The date and time the resource was last modified.
LastModified *time.Time
// The Amazon Resource Name (ARN) of the resource.
ResourceArn *string
// The IAM role that registered a resource.
RoleArn *string
// Whether or not the resource is a federated resource.
WithFederation *bool
noSmithyDocumentSerde
}
// A PartiQL predicate.
type RowFilter struct {
// A wildcard for all rows.
AllRowsWildcard *AllRowsWildcard
// A filter expression.
FilterExpression *string
noSmithyDocumentSerde
}
// A structure describing the configuration and details of a storage optimizer.
type StorageOptimizer struct {
// A map of the storage optimizer configuration. Currently contains only one
// key-value pair: is_enabled indicates true or false for acceleration.
Config map[string]string
// A message that contains information about any error (if present). When an
// acceleration result has an enabled status, the error message is empty. When an
// acceleration result has a disabled status, the message describes an error or
// simply indicates "disabled by the user".
ErrorMessage *string
// When an acceleration result has an enabled status, contains the details of the
// last job run.
LastRunDetails *string
// The specific type of storage optimizer. The supported value is compaction .
StorageOptimizerType OptimizerType
// A message that contains information about any warnings (if present).
Warnings *string
noSmithyDocumentSerde
}
// Specifies the details of a governed table.
type TableObject struct {
// The Amazon S3 ETag of the object. Returned by GetTableObjects for validation
// and used to identify changes to the underlying data.
ETag *string
// The size of the Amazon S3 object in bytes.
Size int64
// The Amazon S3 location of the object.
Uri *string
noSmithyDocumentSerde
}
// A structure for the table object. A table is a metadata definition that
// represents your data. You can Grant and Revoke table privileges to a principal.
type TableResource struct {
// The name of the database for the table. Unique to a Data Catalog. A database is
// a set of associated table definitions organized into a logical group. You can
// Grant and Revoke database privileges to a principal.
//
// This member is required.
DatabaseName *string
// The identifier for the Data Catalog. By default, it is the account ID of the
// caller.
CatalogId *string
// The name of the table.
Name *string
// A wildcard object representing every table under a database. At least one of
// TableResource$Name or TableResource$TableWildcard is required.
TableWildcard *TableWildcard
noSmithyDocumentSerde
}
// A wildcard object representing every table under a database.
type TableWildcard struct {
noSmithyDocumentSerde
}
// A structure for a table with columns object. This object is only used when
// granting a SELECT permission. This object must take a value for at least one of
// ColumnsNames , ColumnsIndexes , or ColumnsWildcard .
type TableWithColumnsResource struct {
// The name of the database for the table with columns resource. Unique to the
// Data Catalog. A database is a set of associated table definitions organized into
// a logical group. You can Grant and Revoke database privileges to a principal.
//
// This member is required.
DatabaseName *string
// The name of the table resource. A table is a metadata definition that
// represents your data. You can Grant and Revoke table privileges to a principal.
//
// This member is required.
Name *string
// The identifier for the Data Catalog. By default, it is the account ID of the
// caller.
CatalogId *string
// The list of column names for the table. At least one of ColumnNames or
// ColumnWildcard is required.
ColumnNames []string
// A wildcard specified by a ColumnWildcard object. At least one of ColumnNames or
// ColumnWildcard is required.
ColumnWildcard *ColumnWildcard
noSmithyDocumentSerde
}
// A structure describing a database resource with LF-tags.
type TaggedDatabase struct {
// A database that has LF-tags attached to it.
Database *DatabaseResource
// A list of LF-tags attached to the database.
LFTags []LFTagPair
noSmithyDocumentSerde
}
// A structure describing a table resource with LF-tags.
type TaggedTable struct {
// A list of LF-tags attached to the database where the table resides.
LFTagOnDatabase []LFTagPair
// A list of LF-tags attached to columns in the table.
LFTagsOnColumns []ColumnLFTag
// A list of LF-tags attached to the table.
LFTagsOnTable []LFTagPair
// A table that has LF-tags attached to it.
Table *TableResource
noSmithyDocumentSerde
}
// A structure that contains information about a transaction.
type TransactionDescription struct {
// The time when the transaction committed or aborted, if it is not currently
// active.
TransactionEndTime *time.Time
// The ID of the transaction.
TransactionId *string
// The time when the transaction started.
TransactionStartTime *time.Time
// A status of ACTIVE, COMMITTED, or ABORTED.
TransactionStatus TransactionStatus
noSmithyDocumentSerde
}
// An object that defines an Amazon S3 object to be deleted if a transaction
// cancels, provided that VirtualPut was called before writing the object.
type VirtualObject struct {
// The path to the Amazon S3 object. Must start with s3://
//
// This member is required.
Uri *string
// The ETag of the Amazon S3 object.
ETag *string
noSmithyDocumentSerde
}
// Defines the valid range of work unit IDs for querying the execution service.
type WorkUnitRange struct {
// Defines the maximum work unit ID in the range. The maximum value is inclusive.
//
// This member is required.
WorkUnitIdMax int64
// Defines the minimum work unit ID in the range.
//
// This member is required.
WorkUnitIdMin int64
// A work token used to query the execution service.
//
// This member is required.
WorkUnitToken *string
noSmithyDocumentSerde
}
// Defines an object to add to or delete from a governed table.
type WriteOperation struct {
// A new object to add to the governed table.
AddObject *AddObjectInput
// An object to delete from the governed table.
DeleteObject *DeleteObjectInput
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 832 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "Lambda"
const ServiceAPIVersion = "2015-03-31"
// Client provides the API client to make operations call for AWS Lambda.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
setSafeEventStreamClientLogMode(&options, opID)
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "lambda", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 436 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds permissions to the resource-based policy of a version of an Lambda layer (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// . Use this action to grant layer usage permission to other accounts. You can
// grant permission to a single account, all accounts in an organization, or all
// Amazon Web Services accounts. To revoke permission, call
// RemoveLayerVersionPermission with the statement ID that you specified when you
// added it.
func (c *Client) AddLayerVersionPermission(ctx context.Context, params *AddLayerVersionPermissionInput, optFns ...func(*Options)) (*AddLayerVersionPermissionOutput, error) {
if params == nil {
params = &AddLayerVersionPermissionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AddLayerVersionPermission", params, optFns, c.addOperationAddLayerVersionPermissionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AddLayerVersionPermissionOutput)
out.ResultMetadata = metadata
return out, nil
}
type AddLayerVersionPermissionInput struct {
// The API action that grants access to the layer. For example,
// lambda:GetLayerVersion .
//
// This member is required.
Action *string
// The name or Amazon Resource Name (ARN) of the layer.
//
// This member is required.
LayerName *string
// An account ID, or * to grant layer usage permission to all accounts in an
// organization, or all Amazon Web Services accounts (if organizationId is not
// specified). For the last case, make sure that you really do want all Amazon Web
// Services accounts to have usage permission to this layer.
//
// This member is required.
Principal *string
// An identifier that distinguishes the policy from others on the same layer
// version.
//
// This member is required.
StatementId *string
// The version number.
//
// This member is required.
VersionNumber int64
// With the principal set to * , grant permission to all accounts in the specified
// organization.
OrganizationId *string
// Only update the policy if the revision ID matches the ID specified. Use this
// option to avoid modifying a policy that has changed since you last read it.
RevisionId *string
noSmithyDocumentSerde
}
type AddLayerVersionPermissionOutput struct {
// A unique identifier for the current revision of the policy.
RevisionId *string
// The permission statement.
Statement *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAddLayerVersionPermissionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAddLayerVersionPermission{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAddLayerVersionPermission{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpAddLayerVersionPermissionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAddLayerVersionPermission(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAddLayerVersionPermission(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "AddLayerVersionPermission",
}
}
| 165 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Grants an Amazon Web Service, Amazon Web Services account, or Amazon Web
// Services organization permission to use a function. You can apply the policy at
// the function level, or specify a qualifier to restrict access to a single
// version or alias. If you use a qualifier, the invoker must use the full Amazon
// Resource Name (ARN) of that version or alias to invoke the function. Note:
// Lambda does not support adding policies to version $LATEST. To grant permission
// to another account, specify the account ID as the Principal . To grant
// permission to an organization defined in Organizations, specify the organization
// ID as the PrincipalOrgID . For Amazon Web Services, the principal is a
// domain-style identifier that the service defines, such as s3.amazonaws.com or
// sns.amazonaws.com . For Amazon Web Services, you can also specify the ARN of the
// associated resource as the SourceArn . If you grant permission to a service
// principal without specifying the source, other accounts could potentially
// configure resources in their account to invoke your Lambda function. This
// operation adds a statement to a resource-based permissions policy for the
// function. For more information about function policies, see Using
// resource-based policies for Lambda (https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html)
// .
func (c *Client) AddPermission(ctx context.Context, params *AddPermissionInput, optFns ...func(*Options)) (*AddPermissionOutput, error) {
if params == nil {
params = &AddPermissionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AddPermission", params, optFns, c.addOperationAddPermissionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AddPermissionOutput)
out.ResultMetadata = metadata
return out, nil
}
type AddPermissionInput struct {
// The action that the principal can use on the function. For example,
// lambda:InvokeFunction or lambda:GetFunction .
//
// This member is required.
Action *string
// The name of the Lambda function, version, or alias. Name formats
// - Function name – my-function (name-only), my-function:v1 (with alias).
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// You can append a version number or alias to any of the formats. The length
// constraint applies only to the full ARN. If you specify only the function name,
// it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The Amazon Web Service or Amazon Web Services account that invokes the
// function. If you specify a service, use SourceArn or SourceAccount to limit who
// can invoke the function through that service.
//
// This member is required.
Principal *string
// A statement identifier that differentiates the statement from others in the
// same policy.
//
// This member is required.
StatementId *string
// For Alexa Smart Home functions, a token that the invoker must supply.
EventSourceToken *string
// The type of authentication that your function URL uses. Set to AWS_IAM if you
// want to restrict access to authenticated users only. Set to NONE if you want to
// bypass IAM authentication to create a public endpoint. For more information, see
// Security and auth model for Lambda function URLs (https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html)
// .
FunctionUrlAuthType types.FunctionUrlAuthType
// The identifier for your organization in Organizations. Use this to grant
// permissions to all the Amazon Web Services accounts under this organization.
PrincipalOrgID *string
// Specify a version or alias to add permissions to a published version of the
// function.
Qualifier *string
// Update the policy only if the revision ID matches the ID that's specified. Use
// this option to avoid modifying a policy that has changed since you last read it.
RevisionId *string
// For Amazon Web Service, the ID of the Amazon Web Services account that owns the
// resource. Use this together with SourceArn to ensure that the specified account
// owns the resource. It is possible for an Amazon S3 bucket to be deleted by its
// owner and recreated by another account.
SourceAccount *string
// For Amazon Web Services, the ARN of the Amazon Web Services resource that
// invokes the function. For example, an Amazon S3 bucket or Amazon SNS topic. Note
// that Lambda configures the comparison using the StringLike operator.
SourceArn *string
noSmithyDocumentSerde
}
type AddPermissionOutput struct {
// The permission statement that's added to the function policy.
Statement *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAddPermissionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAddPermission{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAddPermission{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpAddPermissionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAddPermission(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAddPermission(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "AddPermission",
}
}
| 200 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an alias (https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html)
// for a Lambda function version. Use aliases to provide clients with a function
// identifier that you can update to invoke a different version. You can also map
// an alias to split invocation requests between two versions. Use the
// RoutingConfig parameter to specify a second version and the percentage of
// invocation requests that it receives.
func (c *Client) CreateAlias(ctx context.Context, params *CreateAliasInput, optFns ...func(*Options)) (*CreateAliasOutput, error) {
if params == nil {
params = &CreateAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAlias", params, optFns, c.addOperationCreateAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAliasInput struct {
// The name of the Lambda function. Name formats
// - Function name - MyFunction .
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction .
// - Partial ARN - 123456789012:function:MyFunction .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The function version that the alias invokes.
//
// This member is required.
FunctionVersion *string
// The name of the alias.
//
// This member is required.
Name *string
// A description of the alias.
Description *string
// The routing configuration (https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html#configuring-alias-routing)
// of the alias.
RoutingConfig *types.AliasRoutingConfiguration
noSmithyDocumentSerde
}
// Provides configuration information about a Lambda function alias (https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html)
// .
type CreateAliasOutput struct {
// The Amazon Resource Name (ARN) of the alias.
AliasArn *string
// A description of the alias.
Description *string
// The function version that the alias invokes.
FunctionVersion *string
// The name of the alias.
Name *string
// A unique identifier that changes when you update the alias.
RevisionId *string
// The routing configuration (https://docs.aws.amazon.com/lambda/latest/dg/lambda-traffic-shifting-using-aliases.html)
// of the alias.
RoutingConfig *types.AliasRoutingConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "CreateAlias",
}
}
| 170 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a code signing configuration. A code signing configuration (https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html)
// defines a list of allowed signing profiles and defines the code-signing
// validation policy (action to be taken if deployment validation checks fail).
func (c *Client) CreateCodeSigningConfig(ctx context.Context, params *CreateCodeSigningConfigInput, optFns ...func(*Options)) (*CreateCodeSigningConfigOutput, error) {
if params == nil {
params = &CreateCodeSigningConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateCodeSigningConfig", params, optFns, c.addOperationCreateCodeSigningConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateCodeSigningConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateCodeSigningConfigInput struct {
// Signing profiles for this code signing configuration.
//
// This member is required.
AllowedPublishers *types.AllowedPublishers
// The code signing policies define the actions to take if the validation checks
// fail.
CodeSigningPolicies *types.CodeSigningPolicies
// Descriptive name for this code signing configuration.
Description *string
noSmithyDocumentSerde
}
type CreateCodeSigningConfigOutput struct {
// The code signing configuration.
//
// This member is required.
CodeSigningConfig *types.CodeSigningConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateCodeSigningConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateCodeSigningConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateCodeSigningConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateCodeSigningConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "CreateCodeSigningConfig",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Creates a mapping between an event source and an Lambda function. Lambda reads
// items from the event source and invokes the function. For details about how to
// configure different event sources, see the following topics.
// - Amazon DynamoDB Streams (https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html#services-dynamodb-eventsourcemapping)
// - Amazon Kinesis (https://docs.aws.amazon.com/lambda/latest/dg/with-kinesis.html#services-kinesis-eventsourcemapping)
// - Amazon SQS (https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#events-sqs-eventsource)
// - Amazon MQ and RabbitMQ (https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping)
// - Amazon MSK (https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html)
// - Apache Kafka (https://docs.aws.amazon.com/lambda/latest/dg/kafka-smaa.html)
// - Amazon DocumentDB (https://docs.aws.amazon.com/lambda/latest/dg/with-documentdb.html)
//
// The following error handling options are available only for stream sources
// (DynamoDB and Kinesis):
// - BisectBatchOnFunctionError – If the function returns an error, split the
// batch in two and retry.
// - DestinationConfig – Send discarded records to an Amazon SQS queue or Amazon
// SNS topic.
// - MaximumRecordAgeInSeconds – Discard records older than the specified age.
// The default value is infinite (-1). When set to infinite (-1), failed records
// are retried until the record expires
// - MaximumRetryAttempts – Discard records after the specified number of
// retries. The default value is infinite (-1). When set to infinite (-1), failed
// records are retried until the record expires.
// - ParallelizationFactor – Process multiple batches from each shard
// concurrently.
//
// For information about which configuration parameters apply to each event
// source, see the following topics.
// - Amazon DynamoDB Streams (https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html#services-ddb-params)
// - Amazon Kinesis (https://docs.aws.amazon.com/lambda/latest/dg/with-kinesis.html#services-kinesis-params)
// - Amazon SQS (https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#services-sqs-params)
// - Amazon MQ and RabbitMQ (https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-params)
// - Amazon MSK (https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html#services-msk-parms)
// - Apache Kafka (https://docs.aws.amazon.com/lambda/latest/dg/with-kafka.html#services-kafka-parms)
// - Amazon DocumentDB (https://docs.aws.amazon.com/lambda/latest/dg/with-documentdb.html#docdb-configuration)
func (c *Client) CreateEventSourceMapping(ctx context.Context, params *CreateEventSourceMappingInput, optFns ...func(*Options)) (*CreateEventSourceMappingOutput, error) {
if params == nil {
params = &CreateEventSourceMappingInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateEventSourceMapping", params, optFns, c.addOperationCreateEventSourceMappingMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateEventSourceMappingOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateEventSourceMappingInput struct {
// The name of the Lambda function. Name formats
// - Function name – MyFunction .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:MyFunction .
// - Version or Alias ARN –
// arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD .
// - Partial ARN – 123456789012:function:MyFunction .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it's limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Specific configuration settings for an Amazon Managed Streaming for Apache
// Kafka (Amazon MSK) event source.
AmazonManagedKafkaEventSourceConfig *types.AmazonManagedKafkaEventSourceConfig
// The maximum number of records in each batch that Lambda pulls from your stream
// or queue and sends to your function. Lambda passes all of the records in the
// batch to the function in a single call, up to the payload limit for synchronous
// invocation (6 MB).
// - Amazon Kinesis – Default 100. Max 10,000.
// - Amazon DynamoDB Streams – Default 100. Max 10,000.
// - Amazon Simple Queue Service – Default 10. For standard queues the max is
// 10,000. For FIFO queues the max is 10.
// - Amazon Managed Streaming for Apache Kafka – Default 100. Max 10,000.
// - Self-managed Apache Kafka – Default 100. Max 10,000.
// - Amazon MQ (ActiveMQ and RabbitMQ) – Default 100. Max 10,000.
// - DocumentDB – Default 100. Max 10,000.
BatchSize *int32
// (Kinesis and DynamoDB Streams only) If the function returns an error, split the
// batch in two and retry.
BisectBatchOnFunctionError *bool
// (Kinesis and DynamoDB Streams only) A standard Amazon SQS queue or standard
// Amazon SNS topic destination for discarded records.
DestinationConfig *types.DestinationConfig
// Specific configuration settings for a DocumentDB event source.
DocumentDBEventSourceConfig *types.DocumentDBEventSourceConfig
// When true, the event source mapping is active. When false, Lambda pauses
// polling and invocation. Default: True
Enabled *bool
// The Amazon Resource Name (ARN) of the event source.
// - Amazon Kinesis – The ARN of the data stream or a stream consumer.
// - Amazon DynamoDB Streams – The ARN of the stream.
// - Amazon Simple Queue Service – The ARN of the queue.
// - Amazon Managed Streaming for Apache Kafka – The ARN of the cluster.
// - Amazon MQ – The ARN of the broker.
// - Amazon DocumentDB – The ARN of the DocumentDB change stream.
EventSourceArn *string
// An object that defines the filter criteria that determine whether Lambda should
// process an event. For more information, see Lambda event filtering (https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html)
// .
FilterCriteria *types.FilterCriteria
// (Kinesis, DynamoDB Streams, and Amazon SQS) A list of current response type
// enums applied to the event source mapping.
FunctionResponseTypes []types.FunctionResponseType
// The maximum amount of time, in seconds, that Lambda spends gathering records
// before invoking the function. You can configure MaximumBatchingWindowInSeconds
// to any value from 0 seconds to 300 seconds in increments of seconds. For streams
// and Amazon SQS event sources, the default batching window is 0 seconds. For
// Amazon MSK, Self-managed Apache Kafka, Amazon MQ, and DocumentDB event sources,
// the default batching window is 500 ms. Note that because you can only change
// MaximumBatchingWindowInSeconds in increments of seconds, you cannot revert back
// to the 500 ms default batching window after you have changed it. To restore the
// default batching window, you must create a new event source mapping. Related
// setting: For streams and Amazon SQS event sources, when you set BatchSize to a
// value greater than 10, you must set MaximumBatchingWindowInSeconds to at least
// 1.
MaximumBatchingWindowInSeconds *int32
// (Kinesis and DynamoDB Streams only) Discard records older than the specified
// age. The default value is infinite (-1).
MaximumRecordAgeInSeconds *int32
// (Kinesis and DynamoDB Streams only) Discard records after the specified number
// of retries. The default value is infinite (-1). When set to infinite (-1),
// failed records are retried until the record expires.
MaximumRetryAttempts *int32
// (Kinesis and DynamoDB Streams only) The number of batches to process from each
// shard concurrently.
ParallelizationFactor *int32
// (MQ) The name of the Amazon MQ broker destination queue to consume.
Queues []string
// (Amazon SQS only) The scaling configuration for the event source. For more
// information, see Configuring maximum concurrency for Amazon SQS event sources (https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#events-sqs-max-concurrency)
// .
ScalingConfig *types.ScalingConfig
// The self-managed Apache Kafka cluster to receive records from.
SelfManagedEventSource *types.SelfManagedEventSource
// Specific configuration settings for a self-managed Apache Kafka event source.
SelfManagedKafkaEventSourceConfig *types.SelfManagedKafkaEventSourceConfig
// An array of authentication protocols or VPC components required to secure your
// event source.
SourceAccessConfigurations []types.SourceAccessConfiguration
// The position in a stream from which to start reading. Required for Amazon
// Kinesis and Amazon DynamoDB Stream event sources. AT_TIMESTAMP is supported
// only for Amazon Kinesis streams, Amazon DocumentDB, Amazon MSK, and self-managed
// Apache Kafka.
StartingPosition types.EventSourcePosition
// With StartingPosition set to AT_TIMESTAMP , the time from which to start
// reading. StartingPositionTimestamp cannot be in the future.
StartingPositionTimestamp *time.Time
// The name of the Kafka topic.
Topics []string
// (Kinesis and DynamoDB Streams only) The duration in seconds of a processing
// window for DynamoDB and Kinesis Streams event sources. A value of 0 seconds
// indicates no tumbling window.
TumblingWindowInSeconds *int32
noSmithyDocumentSerde
}
// A mapping between an Amazon Web Services resource and a Lambda function. For
// details, see CreateEventSourceMapping .
type CreateEventSourceMappingOutput struct {
// Specific configuration settings for an Amazon Managed Streaming for Apache
// Kafka (Amazon MSK) event source.
AmazonManagedKafkaEventSourceConfig *types.AmazonManagedKafkaEventSourceConfig
// The maximum number of records in each batch that Lambda pulls from your stream
// or queue and sends to your function. Lambda passes all of the records in the
// batch to the function in a single call, up to the payload limit for synchronous
// invocation (6 MB). Default value: Varies by service. For Amazon SQS, the default
// is 10. For all other services, the default is 100. Related setting: When you set
// BatchSize to a value greater than 10, you must set
// MaximumBatchingWindowInSeconds to at least 1.
BatchSize *int32
// (Kinesis and DynamoDB Streams only) If the function returns an error, split the
// batch in two and retry. The default value is false.
BisectBatchOnFunctionError *bool
// (Kinesis and DynamoDB Streams only) An Amazon SQS queue or Amazon SNS topic
// destination for discarded records.
DestinationConfig *types.DestinationConfig
// Specific configuration settings for a DocumentDB event source.
DocumentDBEventSourceConfig *types.DocumentDBEventSourceConfig
// The Amazon Resource Name (ARN) of the event source.
EventSourceArn *string
// An object that defines the filter criteria that determine whether Lambda should
// process an event. For more information, see Lambda event filtering (https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html)
// .
FilterCriteria *types.FilterCriteria
// The ARN of the Lambda function.
FunctionArn *string
// (Kinesis, DynamoDB Streams, and Amazon SQS) A list of current response type
// enums applied to the event source mapping.
FunctionResponseTypes []types.FunctionResponseType
// The date that the event source mapping was last updated or that its state
// changed.
LastModified *time.Time
// The result of the last Lambda invocation of your function.
LastProcessingResult *string
// The maximum amount of time, in seconds, that Lambda spends gathering records
// before invoking the function. You can configure MaximumBatchingWindowInSeconds
// to any value from 0 seconds to 300 seconds in increments of seconds. For streams
// and Amazon SQS event sources, the default batching window is 0 seconds. For
// Amazon MSK, Self-managed Apache Kafka, Amazon MQ, and DocumentDB event sources,
// the default batching window is 500 ms. Note that because you can only change
// MaximumBatchingWindowInSeconds in increments of seconds, you cannot revert back
// to the 500 ms default batching window after you have changed it. To restore the
// default batching window, you must create a new event source mapping. Related
// setting: For streams and Amazon SQS event sources, when you set BatchSize to a
// value greater than 10, you must set MaximumBatchingWindowInSeconds to at least
// 1.
MaximumBatchingWindowInSeconds *int32
// (Kinesis and DynamoDB Streams only) Discard records older than the specified
// age. The default value is -1, which sets the maximum age to infinite. When the
// value is set to infinite, Lambda never discards old records. The minimum valid
// value for maximum record age is 60s. Although values less than 60 and greater
// than -1 fall within the parameter's absolute range, they are not allowed
MaximumRecordAgeInSeconds *int32
// (Kinesis and DynamoDB Streams only) Discard records after the specified number
// of retries. The default value is -1, which sets the maximum number of retries to
// infinite. When MaximumRetryAttempts is infinite, Lambda retries failed records
// until the record expires in the event source.
MaximumRetryAttempts *int32
// (Kinesis and DynamoDB Streams only) The number of batches to process
// concurrently from each shard. The default value is 1.
ParallelizationFactor *int32
// (Amazon MQ) The name of the Amazon MQ broker destination queue to consume.
Queues []string
// (Amazon SQS only) The scaling configuration for the event source. For more
// information, see Configuring maximum concurrency for Amazon SQS event sources (https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#events-sqs-max-concurrency)
// .
ScalingConfig *types.ScalingConfig
// The self-managed Apache Kafka cluster for your event source.
SelfManagedEventSource *types.SelfManagedEventSource
// Specific configuration settings for a self-managed Apache Kafka event source.
SelfManagedKafkaEventSourceConfig *types.SelfManagedKafkaEventSourceConfig
// An array of the authentication protocol, VPC components, or virtual host to
// secure and define your event source.
SourceAccessConfigurations []types.SourceAccessConfiguration
// The position in a stream from which to start reading. Required for Amazon
// Kinesis and Amazon DynamoDB Stream event sources. AT_TIMESTAMP is supported
// only for Amazon Kinesis streams, Amazon DocumentDB, Amazon MSK, and self-managed
// Apache Kafka.
StartingPosition types.EventSourcePosition
// With StartingPosition set to AT_TIMESTAMP , the time from which to start
// reading. StartingPositionTimestamp cannot be in the future.
StartingPositionTimestamp *time.Time
// The state of the event source mapping. It can be one of the following: Creating
// , Enabling , Enabled , Disabling , Disabled , Updating , or Deleting .
State *string
// Indicates whether a user or Lambda made the last change to the event source
// mapping.
StateTransitionReason *string
// The name of the Kafka topic.
Topics []string
// (Kinesis and DynamoDB Streams only) The duration in seconds of a processing
// window for DynamoDB and Kinesis Streams event sources. A value of 0 seconds
// indicates no tumbling window.
TumblingWindowInSeconds *int32
// The identifier of the event source mapping.
UUID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateEventSourceMappingMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateEventSourceMapping{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateEventSourceMapping{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateEventSourceMappingValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateEventSourceMapping(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateEventSourceMapping(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "CreateEventSourceMapping",
}
}
| 404 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a Lambda function. To create a function, you need a deployment package (https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html)
// and an execution role (https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role)
// . The deployment package is a .zip file archive or container image that contains
// your function code. The execution role grants the function permission to use
// Amazon Web Services, such as Amazon CloudWatch Logs for log streaming and X-Ray
// for request tracing. If the deployment package is a container image (https://docs.aws.amazon.com/lambda/latest/dg/lambda-images.html)
// , then you set the package type to Image . For a container image, the code
// property must include the URI of a container image in the Amazon ECR registry.
// You do not need to specify the handler and runtime properties. If the deployment
// package is a .zip file archive (https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html#gettingstarted-package-zip)
// , then you set the package type to Zip . For a .zip file archive, the code
// property specifies the location of the .zip file. You must also specify the
// handler and runtime properties. The code in the deployment package must be
// compatible with the target instruction set architecture of the function ( x86-64
// or arm64 ). If you do not specify the architecture, then the default value is
// x86-64 . When you create a function, Lambda provisions an instance of the
// function and its supporting resources. If your function connects to a VPC, this
// process can take a minute or so. During this time, you can't invoke or modify
// the function. The State , StateReason , and StateReasonCode fields in the
// response from GetFunctionConfiguration indicate when the function is ready to
// invoke. For more information, see Lambda function states (https://docs.aws.amazon.com/lambda/latest/dg/functions-states.html)
// . A function has an unpublished version, and can have published versions and
// aliases. The unpublished version changes when you update your function's code
// and configuration. A published version is a snapshot of your function code and
// configuration that can't be changed. An alias is a named resource that maps to a
// version, and can be changed to map to a different version. Use the Publish
// parameter to create version 1 of your function from its initial configuration.
// The other parameters let you configure version-specific and function-level
// settings. You can modify version-specific settings later with
// UpdateFunctionConfiguration . Function-level settings apply to both the
// unpublished and published versions of the function, and include tags (
// TagResource ) and per-function concurrency limits ( PutFunctionConcurrency ).
// You can use code signing if your deployment package is a .zip file archive. To
// enable code signing for this function, specify the ARN of a code-signing
// configuration. When a user attempts to deploy a code package with
// UpdateFunctionCode , Lambda checks that the code package has a valid signature
// from a trusted publisher. The code-signing configuration includes set of signing
// profiles, which define the trusted publishers for this function. If another
// Amazon Web Services account or an Amazon Web Service invokes your function, use
// AddPermission to grant permission by creating a resource-based Identity and
// Access Management (IAM) policy. You can grant permissions at the function level,
// on a version, or on an alias. To invoke your function directly, use Invoke . To
// invoke your function in response to events in other Amazon Web Services, create
// an event source mapping ( CreateEventSourceMapping ), or configure a function
// trigger in the other service. For more information, see Invoking Lambda
// functions (https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html) .
func (c *Client) CreateFunction(ctx context.Context, params *CreateFunctionInput, optFns ...func(*Options)) (*CreateFunctionOutput, error) {
if params == nil {
params = &CreateFunctionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFunction", params, optFns, c.addOperationCreateFunctionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFunctionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFunctionInput struct {
// The code for the function.
//
// This member is required.
Code *types.FunctionCode
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The Amazon Resource Name (ARN) of the function's execution role.
//
// This member is required.
Role *string
// The instruction set architecture that the function supports. Enter a string
// array with one of the valid values (arm64 or x86_64). The default value is
// x86_64 .
Architectures []types.Architecture
// To enable code signing for this function, specify the ARN of a code-signing
// configuration. A code-signing configuration includes a set of signing profiles,
// which define the trusted publishers for this function.
CodeSigningConfigArn *string
// A dead-letter queue configuration that specifies the queue or topic where
// Lambda sends asynchronous events when they fail processing. For more
// information, see Dead-letter queues (https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#invocation-dlq)
// .
DeadLetterConfig *types.DeadLetterConfig
// A description of the function.
Description *string
// Environment variables that are accessible from function code during execution.
Environment *types.Environment
// The size of the function's /tmp directory in MB. The default value is 512, but
// can be any whole number between 512 and 10,240 MB.
EphemeralStorage *types.EphemeralStorage
// Connection settings for an Amazon EFS file system.
FileSystemConfigs []types.FileSystemConfig
// The name of the method within your code that Lambda calls to run your function.
// Handler is required if the deployment package is a .zip file archive. The format
// includes the file name. It can also include namespaces and other qualifiers,
// depending on the runtime. For more information, see Lambda programming model (https://docs.aws.amazon.com/lambda/latest/dg/foundation-progmodel.html)
// .
Handler *string
// Container image configuration values (https://docs.aws.amazon.com/lambda/latest/dg/configuration-images.html#configuration-images-settings)
// that override the values in the container image Dockerfile.
ImageConfig *types.ImageConfig
// The ARN of the Key Management Service (KMS) customer managed key that's used to
// encrypt your function's environment variables (https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-encryption)
// . When Lambda SnapStart (https://docs.aws.amazon.com/lambda/latest/dg/snapstart-security.html)
// is activated, Lambda also uses this key is to encrypt your function's snapshot.
// If you deploy your function using a container image, Lambda also uses this key
// to encrypt your function when it's deployed. Note that this is not the same key
// that's used to protect your container image in the Amazon Elastic Container
// Registry (Amazon ECR). If you don't provide a customer managed key, Lambda uses
// a default service key.
KMSKeyArn *string
// A list of function layers (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// to add to the function's execution environment. Specify each layer by its ARN,
// including the version.
Layers []string
// The amount of memory available to the function (https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html#configuration-memory-console)
// at runtime. Increasing the function memory also increases its CPU allocation.
// The default value is 128 MB. The value can be any multiple of 1 MB.
MemorySize *int32
// The type of deployment package. Set to Image for container image and set to Zip
// for .zip file archive.
PackageType types.PackageType
// Set to true to publish the first version of the function during creation.
Publish bool
// The identifier of the function's runtime (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html)
// . Runtime is required if the deployment package is a .zip file archive. The
// following list includes deprecated runtimes. For more information, see Runtime
// deprecation policy (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-support-policy)
// .
Runtime types.Runtime
// The function's SnapStart (https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html)
// setting.
SnapStart *types.SnapStart
// A list of tags (https://docs.aws.amazon.com/lambda/latest/dg/tagging.html) to
// apply to the function.
Tags map[string]string
// The amount of time (in seconds) that Lambda allows a function to run before
// stopping it. The default is 3 seconds. The maximum allowed value is 900 seconds.
// For more information, see Lambda execution environment (https://docs.aws.amazon.com/lambda/latest/dg/runtimes-context.html)
// .
Timeout *int32
// Set Mode to Active to sample and trace a subset of incoming requests with X-Ray (https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html)
// .
TracingConfig *types.TracingConfig
// For network connectivity to Amazon Web Services resources in a VPC, specify a
// list of security groups and subnets in the VPC. When you connect a function to a
// VPC, it can access resources and the internet only through that VPC. For more
// information, see Configuring a Lambda function to access resources in a VPC (https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html)
// .
VpcConfig *types.VpcConfig
noSmithyDocumentSerde
}
// Details about a function's configuration.
type CreateFunctionOutput struct {
// The instruction set architecture that the function supports. Architecture is a
// string array with one of the valid values. The default architecture value is
// x86_64 .
Architectures []types.Architecture
// The SHA256 hash of the function's deployment package.
CodeSha256 *string
// The size of the function's deployment package, in bytes.
CodeSize int64
// The function's dead letter queue.
DeadLetterConfig *types.DeadLetterConfig
// The function's description.
Description *string
// The function's environment variables (https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html)
// . Omitted from CloudTrail logs.
Environment *types.EnvironmentResponse
// The size of the function’s /tmp directory in MB. The default value is 512, but
// it can be any whole number between 512 and 10,240 MB.
EphemeralStorage *types.EphemeralStorage
// Connection settings for an Amazon EFS file system (https://docs.aws.amazon.com/lambda/latest/dg/configuration-filesystem.html)
// .
FileSystemConfigs []types.FileSystemConfig
// The function's Amazon Resource Name (ARN).
FunctionArn *string
// The name of the function.
FunctionName *string
// The function that Lambda calls to begin running your function.
Handler *string
// The function's image configuration values.
ImageConfigResponse *types.ImageConfigResponse
// The KMS key that's used to encrypt the function's environment variables (https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-encryption)
// . When Lambda SnapStart (https://docs.aws.amazon.com/lambda/latest/dg/snapstart-security.html)
// is activated, this key is also used to encrypt the function's snapshot. This key
// is returned only if you've configured a customer managed key.
KMSKeyArn *string
// The date and time that the function was last updated, in ISO-8601 format (https://www.w3.org/TR/NOTE-datetime)
// (YYYY-MM-DDThh:mm:ss.sTZD).
LastModified *string
// The status of the last update that was performed on the function. This is first
// set to Successful after function creation completes.
LastUpdateStatus types.LastUpdateStatus
// The reason for the last update that was performed on the function.
LastUpdateStatusReason *string
// The reason code for the last update that was performed on the function.
LastUpdateStatusReasonCode types.LastUpdateStatusReasonCode
// The function's layers (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// .
Layers []types.Layer
// For Lambda@Edge functions, the ARN of the main function.
MasterArn *string
// The amount of memory available to the function at runtime.
MemorySize *int32
// The type of deployment package. Set to Image for container image and set Zip
// for .zip file archive.
PackageType types.PackageType
// The latest updated revision of the function or alias.
RevisionId *string
// The function's execution role.
Role *string
// The identifier of the function's runtime (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html)
// . Runtime is required if the deployment package is a .zip file archive. The
// following list includes deprecated runtimes. For more information, see Runtime
// deprecation policy (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-support-policy)
// .
Runtime types.Runtime
// The ARN of the runtime and any errors that occured.
RuntimeVersionConfig *types.RuntimeVersionConfig
// The ARN of the signing job.
SigningJobArn *string
// The ARN of the signing profile version.
SigningProfileVersionArn *string
// Set ApplyOn to PublishedVersions to create a snapshot of the initialized
// execution environment when you publish a function version. For more information,
// see Improving startup performance with Lambda SnapStart (https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html)
// .
SnapStart *types.SnapStartResponse
// The current state of the function. When the state is Inactive , you can
// reactivate the function by invoking it.
State types.State
// The reason for the function's current state.
StateReason *string
// The reason code for the function's current state. When the code is Creating ,
// you can't invoke or modify the function.
StateReasonCode types.StateReasonCode
// The amount of time in seconds that Lambda allows a function to run before
// stopping it.
Timeout *int32
// The function's X-Ray tracing configuration.
TracingConfig *types.TracingConfigResponse
// The version of the Lambda function.
Version *string
// The function's networking configuration.
VpcConfig *types.VpcConfigResponse
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateFunctionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateFunction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateFunction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateFunctionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateFunction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateFunction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "CreateFunction",
}
}
| 410 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a Lambda function URL with the specified configuration parameters. A
// function URL is a dedicated HTTP(S) endpoint that you can use to invoke your
// function.
func (c *Client) CreateFunctionUrlConfig(ctx context.Context, params *CreateFunctionUrlConfigInput, optFns ...func(*Options)) (*CreateFunctionUrlConfigOutput, error) {
if params == nil {
params = &CreateFunctionUrlConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFunctionUrlConfig", params, optFns, c.addOperationCreateFunctionUrlConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFunctionUrlConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFunctionUrlConfigInput struct {
// The type of authentication that your function URL uses. Set to AWS_IAM if you
// want to restrict access to authenticated users only. Set to NONE if you want to
// bypass IAM authentication to create a public endpoint. For more information, see
// Security and auth model for Lambda function URLs (https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html)
// .
//
// This member is required.
AuthType types.FunctionUrlAuthType
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The cross-origin resource sharing (CORS) (https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)
// settings for your function URL.
Cors *types.Cors
// Use one of the following options:
// - BUFFERED – This is the default option. Lambda invokes your function using
// the Invoke API operation. Invocation results are available when the payload is
// complete. The maximum payload size is 6 MB.
// - RESPONSE_STREAM – Your function streams payload results as they become
// available. Lambda invokes your function using the InvokeWithResponseStream API
// operation. The maximum response payload size is 20 MB, however, you can
// request a quota increase (https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html)
// .
InvokeMode types.InvokeMode
// The alias name.
Qualifier *string
noSmithyDocumentSerde
}
type CreateFunctionUrlConfigOutput struct {
// The type of authentication that your function URL uses. Set to AWS_IAM if you
// want to restrict access to authenticated users only. Set to NONE if you want to
// bypass IAM authentication to create a public endpoint. For more information, see
// Security and auth model for Lambda function URLs (https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html)
// .
//
// This member is required.
AuthType types.FunctionUrlAuthType
// When the function URL was created, in ISO-8601 format (https://www.w3.org/TR/NOTE-datetime)
// (YYYY-MM-DDThh:mm:ss.sTZD).
//
// This member is required.
CreationTime *string
// The Amazon Resource Name (ARN) of your function.
//
// This member is required.
FunctionArn *string
// The HTTP URL endpoint for your function.
//
// This member is required.
FunctionUrl *string
// The cross-origin resource sharing (CORS) (https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)
// settings for your function URL.
Cors *types.Cors
// Use one of the following options:
// - BUFFERED – This is the default option. Lambda invokes your function using
// the Invoke API operation. Invocation results are available when the payload is
// complete. The maximum payload size is 6 MB.
// - RESPONSE_STREAM – Your function streams payload results as they become
// available. Lambda invokes your function using the InvokeWithResponseStream API
// operation. The maximum response payload size is 20 MB, however, you can
// request a quota increase (https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html)
// .
InvokeMode types.InvokeMode
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateFunctionUrlConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateFunctionUrlConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateFunctionUrlConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateFunctionUrlConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateFunctionUrlConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateFunctionUrlConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "CreateFunctionUrlConfig",
}
}
| 196 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a Lambda function alias (https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html)
// .
func (c *Client) DeleteAlias(ctx context.Context, params *DeleteAliasInput, optFns ...func(*Options)) (*DeleteAliasOutput, error) {
if params == nil {
params = &DeleteAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAlias", params, optFns, c.addOperationDeleteAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAliasInput struct {
// The name of the Lambda function. Name formats
// - Function name - MyFunction .
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction .
// - Partial ARN - 123456789012:function:MyFunction .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The name of the alias.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
type DeleteAliasOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteAlias",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the code signing configuration. You can delete the code signing
// configuration only if no function is using it.
func (c *Client) DeleteCodeSigningConfig(ctx context.Context, params *DeleteCodeSigningConfigInput, optFns ...func(*Options)) (*DeleteCodeSigningConfigOutput, error) {
if params == nil {
params = &DeleteCodeSigningConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteCodeSigningConfig", params, optFns, c.addOperationDeleteCodeSigningConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteCodeSigningConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteCodeSigningConfigInput struct {
// The The Amazon Resource Name (ARN) of the code signing configuration.
//
// This member is required.
CodeSigningConfigArn *string
noSmithyDocumentSerde
}
type DeleteCodeSigningConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteCodeSigningConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteCodeSigningConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCodeSigningConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteCodeSigningConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteCodeSigningConfig",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Deletes an event source mapping (https://docs.aws.amazon.com/lambda/latest/dg/intro-invocation-modes.html)
// . You can get the identifier of a mapping from the output of
// ListEventSourceMappings . When you delete an event source mapping, it enters a
// Deleting state and might not be completely deleted for several seconds.
func (c *Client) DeleteEventSourceMapping(ctx context.Context, params *DeleteEventSourceMappingInput, optFns ...func(*Options)) (*DeleteEventSourceMappingOutput, error) {
if params == nil {
params = &DeleteEventSourceMappingInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteEventSourceMapping", params, optFns, c.addOperationDeleteEventSourceMappingMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteEventSourceMappingOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteEventSourceMappingInput struct {
// The identifier of the event source mapping.
//
// This member is required.
UUID *string
noSmithyDocumentSerde
}
// A mapping between an Amazon Web Services resource and a Lambda function. For
// details, see CreateEventSourceMapping .
type DeleteEventSourceMappingOutput struct {
// Specific configuration settings for an Amazon Managed Streaming for Apache
// Kafka (Amazon MSK) event source.
AmazonManagedKafkaEventSourceConfig *types.AmazonManagedKafkaEventSourceConfig
// The maximum number of records in each batch that Lambda pulls from your stream
// or queue and sends to your function. Lambda passes all of the records in the
// batch to the function in a single call, up to the payload limit for synchronous
// invocation (6 MB). Default value: Varies by service. For Amazon SQS, the default
// is 10. For all other services, the default is 100. Related setting: When you set
// BatchSize to a value greater than 10, you must set
// MaximumBatchingWindowInSeconds to at least 1.
BatchSize *int32
// (Kinesis and DynamoDB Streams only) If the function returns an error, split the
// batch in two and retry. The default value is false.
BisectBatchOnFunctionError *bool
// (Kinesis and DynamoDB Streams only) An Amazon SQS queue or Amazon SNS topic
// destination for discarded records.
DestinationConfig *types.DestinationConfig
// Specific configuration settings for a DocumentDB event source.
DocumentDBEventSourceConfig *types.DocumentDBEventSourceConfig
// The Amazon Resource Name (ARN) of the event source.
EventSourceArn *string
// An object that defines the filter criteria that determine whether Lambda should
// process an event. For more information, see Lambda event filtering (https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html)
// .
FilterCriteria *types.FilterCriteria
// The ARN of the Lambda function.
FunctionArn *string
// (Kinesis, DynamoDB Streams, and Amazon SQS) A list of current response type
// enums applied to the event source mapping.
FunctionResponseTypes []types.FunctionResponseType
// The date that the event source mapping was last updated or that its state
// changed.
LastModified *time.Time
// The result of the last Lambda invocation of your function.
LastProcessingResult *string
// The maximum amount of time, in seconds, that Lambda spends gathering records
// before invoking the function. You can configure MaximumBatchingWindowInSeconds
// to any value from 0 seconds to 300 seconds in increments of seconds. For streams
// and Amazon SQS event sources, the default batching window is 0 seconds. For
// Amazon MSK, Self-managed Apache Kafka, Amazon MQ, and DocumentDB event sources,
// the default batching window is 500 ms. Note that because you can only change
// MaximumBatchingWindowInSeconds in increments of seconds, you cannot revert back
// to the 500 ms default batching window after you have changed it. To restore the
// default batching window, you must create a new event source mapping. Related
// setting: For streams and Amazon SQS event sources, when you set BatchSize to a
// value greater than 10, you must set MaximumBatchingWindowInSeconds to at least
// 1.
MaximumBatchingWindowInSeconds *int32
// (Kinesis and DynamoDB Streams only) Discard records older than the specified
// age. The default value is -1, which sets the maximum age to infinite. When the
// value is set to infinite, Lambda never discards old records. The minimum valid
// value for maximum record age is 60s. Although values less than 60 and greater
// than -1 fall within the parameter's absolute range, they are not allowed
MaximumRecordAgeInSeconds *int32
// (Kinesis and DynamoDB Streams only) Discard records after the specified number
// of retries. The default value is -1, which sets the maximum number of retries to
// infinite. When MaximumRetryAttempts is infinite, Lambda retries failed records
// until the record expires in the event source.
MaximumRetryAttempts *int32
// (Kinesis and DynamoDB Streams only) The number of batches to process
// concurrently from each shard. The default value is 1.
ParallelizationFactor *int32
// (Amazon MQ) The name of the Amazon MQ broker destination queue to consume.
Queues []string
// (Amazon SQS only) The scaling configuration for the event source. For more
// information, see Configuring maximum concurrency for Amazon SQS event sources (https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#events-sqs-max-concurrency)
// .
ScalingConfig *types.ScalingConfig
// The self-managed Apache Kafka cluster for your event source.
SelfManagedEventSource *types.SelfManagedEventSource
// Specific configuration settings for a self-managed Apache Kafka event source.
SelfManagedKafkaEventSourceConfig *types.SelfManagedKafkaEventSourceConfig
// An array of the authentication protocol, VPC components, or virtual host to
// secure and define your event source.
SourceAccessConfigurations []types.SourceAccessConfiguration
// The position in a stream from which to start reading. Required for Amazon
// Kinesis and Amazon DynamoDB Stream event sources. AT_TIMESTAMP is supported
// only for Amazon Kinesis streams, Amazon DocumentDB, Amazon MSK, and self-managed
// Apache Kafka.
StartingPosition types.EventSourcePosition
// With StartingPosition set to AT_TIMESTAMP , the time from which to start
// reading. StartingPositionTimestamp cannot be in the future.
StartingPositionTimestamp *time.Time
// The state of the event source mapping. It can be one of the following: Creating
// , Enabling , Enabled , Disabling , Disabled , Updating , or Deleting .
State *string
// Indicates whether a user or Lambda made the last change to the event source
// mapping.
StateTransitionReason *string
// The name of the Kafka topic.
Topics []string
// (Kinesis and DynamoDB Streams only) The duration in seconds of a processing
// window for DynamoDB and Kinesis Streams event sources. A value of 0 seconds
// indicates no tumbling window.
TumblingWindowInSeconds *int32
// The identifier of the event source mapping.
UUID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteEventSourceMappingMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteEventSourceMapping{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteEventSourceMapping{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteEventSourceMappingValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteEventSourceMapping(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteEventSourceMapping(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteEventSourceMapping",
}
}
| 252 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a Lambda function. To delete a specific function version, use the
// Qualifier parameter. Otherwise, all versions and aliases are deleted. This
// doesn't require the user to have explicit permissions for DeleteAlias . To
// delete Lambda event source mappings that invoke a function, use
// DeleteEventSourceMapping . For Amazon Web Services and resources that invoke
// your function directly, delete the trigger in the service where you originally
// configured it.
func (c *Client) DeleteFunction(ctx context.Context, params *DeleteFunctionInput, optFns ...func(*Options)) (*DeleteFunctionOutput, error) {
if params == nil {
params = &DeleteFunctionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFunction", params, optFns, c.addOperationDeleteFunctionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFunctionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFunctionInput struct {
// The name of the Lambda function or version. Name formats
// - Function name – my-function (name-only), my-function:1 (with version).
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// You can append a version number or alias to any of the formats. The length
// constraint applies only to the full ARN. If you specify only the function name,
// it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Specify a version to delete. You can't delete a version that an alias
// references.
Qualifier *string
noSmithyDocumentSerde
}
type DeleteFunctionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFunctionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteFunction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteFunction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFunctionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFunction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFunction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteFunction",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes the code signing configuration from the function.
func (c *Client) DeleteFunctionCodeSigningConfig(ctx context.Context, params *DeleteFunctionCodeSigningConfigInput, optFns ...func(*Options)) (*DeleteFunctionCodeSigningConfigOutput, error) {
if params == nil {
params = &DeleteFunctionCodeSigningConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFunctionCodeSigningConfig", params, optFns, c.addOperationDeleteFunctionCodeSigningConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFunctionCodeSigningConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFunctionCodeSigningConfigInput struct {
// The name of the Lambda function. Name formats
// - Function name - MyFunction .
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction .
// - Partial ARN - 123456789012:function:MyFunction .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
noSmithyDocumentSerde
}
type DeleteFunctionCodeSigningConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFunctionCodeSigningConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteFunctionCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteFunctionCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFunctionCodeSigningConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFunctionCodeSigningConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFunctionCodeSigningConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteFunctionCodeSigningConfig",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes a concurrent execution limit from a function.
func (c *Client) DeleteFunctionConcurrency(ctx context.Context, params *DeleteFunctionConcurrencyInput, optFns ...func(*Options)) (*DeleteFunctionConcurrencyOutput, error) {
if params == nil {
params = &DeleteFunctionConcurrencyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFunctionConcurrency", params, optFns, c.addOperationDeleteFunctionConcurrencyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFunctionConcurrencyOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFunctionConcurrencyInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
noSmithyDocumentSerde
}
type DeleteFunctionConcurrencyOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFunctionConcurrencyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteFunctionConcurrency{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteFunctionConcurrency{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFunctionConcurrencyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFunctionConcurrency(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFunctionConcurrency(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteFunctionConcurrency",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the configuration for asynchronous invocation for a function, version,
// or alias. To configure options for asynchronous invocation, use
// PutFunctionEventInvokeConfig .
func (c *Client) DeleteFunctionEventInvokeConfig(ctx context.Context, params *DeleteFunctionEventInvokeConfigInput, optFns ...func(*Options)) (*DeleteFunctionEventInvokeConfigOutput, error) {
if params == nil {
params = &DeleteFunctionEventInvokeConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFunctionEventInvokeConfig", params, optFns, c.addOperationDeleteFunctionEventInvokeConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFunctionEventInvokeConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFunctionEventInvokeConfigInput struct {
// The name of the Lambda function, version, or alias. Name formats
// - Function name - my-function (name-only), my-function:v1 (with alias).
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN - 123456789012:function:my-function .
// You can append a version number or alias to any of the formats. The length
// constraint applies only to the full ARN. If you specify only the function name,
// it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// A version number or alias name.
Qualifier *string
noSmithyDocumentSerde
}
type DeleteFunctionEventInvokeConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFunctionEventInvokeConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteFunctionEventInvokeConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteFunctionEventInvokeConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFunctionEventInvokeConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFunctionEventInvokeConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFunctionEventInvokeConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteFunctionEventInvokeConfig",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a Lambda function URL. When you delete a function URL, you can't
// recover it. Creating a new function URL results in a different URL address.
func (c *Client) DeleteFunctionUrlConfig(ctx context.Context, params *DeleteFunctionUrlConfigInput, optFns ...func(*Options)) (*DeleteFunctionUrlConfigOutput, error) {
if params == nil {
params = &DeleteFunctionUrlConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFunctionUrlConfig", params, optFns, c.addOperationDeleteFunctionUrlConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFunctionUrlConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFunctionUrlConfigInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The alias name.
Qualifier *string
noSmithyDocumentSerde
}
type DeleteFunctionUrlConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFunctionUrlConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteFunctionUrlConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteFunctionUrlConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFunctionUrlConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFunctionUrlConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFunctionUrlConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteFunctionUrlConfig",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a version of an Lambda layer (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// . Deleted versions can no longer be viewed or added to functions. To avoid
// breaking functions, a copy of the version remains in Lambda until no functions
// refer to it.
func (c *Client) DeleteLayerVersion(ctx context.Context, params *DeleteLayerVersionInput, optFns ...func(*Options)) (*DeleteLayerVersionOutput, error) {
if params == nil {
params = &DeleteLayerVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteLayerVersion", params, optFns, c.addOperationDeleteLayerVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteLayerVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteLayerVersionInput struct {
// The name or Amazon Resource Name (ARN) of the layer.
//
// This member is required.
LayerName *string
// The version number.
//
// This member is required.
VersionNumber int64
noSmithyDocumentSerde
}
type DeleteLayerVersionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteLayerVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteLayerVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteLayerVersion{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteLayerVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteLayerVersion(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteLayerVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteLayerVersion",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the provisioned concurrency configuration for a function.
func (c *Client) DeleteProvisionedConcurrencyConfig(ctx context.Context, params *DeleteProvisionedConcurrencyConfigInput, optFns ...func(*Options)) (*DeleteProvisionedConcurrencyConfigOutput, error) {
if params == nil {
params = &DeleteProvisionedConcurrencyConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteProvisionedConcurrencyConfig", params, optFns, c.addOperationDeleteProvisionedConcurrencyConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteProvisionedConcurrencyConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteProvisionedConcurrencyConfigInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The version number or alias name.
//
// This member is required.
Qualifier *string
noSmithyDocumentSerde
}
type DeleteProvisionedConcurrencyConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteProvisionedConcurrencyConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteProvisionedConcurrencyConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteProvisionedConcurrencyConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteProvisionedConcurrencyConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteProvisionedConcurrencyConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteProvisionedConcurrencyConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "DeleteProvisionedConcurrencyConfig",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves details about your account's limits (https://docs.aws.amazon.com/lambda/latest/dg/limits.html)
// and usage in an Amazon Web Services Region.
func (c *Client) GetAccountSettings(ctx context.Context, params *GetAccountSettingsInput, optFns ...func(*Options)) (*GetAccountSettingsOutput, error) {
if params == nil {
params = &GetAccountSettingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetAccountSettings", params, optFns, c.addOperationGetAccountSettingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetAccountSettingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetAccountSettingsInput struct {
noSmithyDocumentSerde
}
type GetAccountSettingsOutput struct {
// Limits that are related to concurrency and code storage.
AccountLimit *types.AccountLimit
// The number of functions and amount of storage in use.
AccountUsage *types.AccountUsage
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetAccountSettingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetAccountSettings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetAccountSettings{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetAccountSettings(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetAccountSettings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetAccountSettings",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns details about a Lambda function alias (https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html)
// .
func (c *Client) GetAlias(ctx context.Context, params *GetAliasInput, optFns ...func(*Options)) (*GetAliasOutput, error) {
if params == nil {
params = &GetAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetAlias", params, optFns, c.addOperationGetAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetAliasInput struct {
// The name of the Lambda function. Name formats
// - Function name - MyFunction .
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction .
// - Partial ARN - 123456789012:function:MyFunction .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The name of the alias.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
// Provides configuration information about a Lambda function alias (https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html)
// .
type GetAliasOutput struct {
// The Amazon Resource Name (ARN) of the alias.
AliasArn *string
// A description of the alias.
Description *string
// The function version that the alias invokes.
FunctionVersion *string
// The name of the alias.
Name *string
// A unique identifier that changes when you update the alias.
RevisionId *string
// The routing configuration (https://docs.aws.amazon.com/lambda/latest/dg/lambda-traffic-shifting-using-aliases.html)
// of the alias.
RoutingConfig *types.AliasRoutingConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetAlias",
}
}
| 154 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about the specified code signing configuration.
func (c *Client) GetCodeSigningConfig(ctx context.Context, params *GetCodeSigningConfigInput, optFns ...func(*Options)) (*GetCodeSigningConfigOutput, error) {
if params == nil {
params = &GetCodeSigningConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetCodeSigningConfig", params, optFns, c.addOperationGetCodeSigningConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetCodeSigningConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetCodeSigningConfigInput struct {
// The The Amazon Resource Name (ARN) of the code signing configuration.
//
// This member is required.
CodeSigningConfigArn *string
noSmithyDocumentSerde
}
type GetCodeSigningConfigOutput struct {
// The code signing configuration
//
// This member is required.
CodeSigningConfig *types.CodeSigningConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetCodeSigningConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetCodeSigningConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCodeSigningConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetCodeSigningConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetCodeSigningConfig",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Returns details about an event source mapping. You can get the identifier of a
// mapping from the output of ListEventSourceMappings .
func (c *Client) GetEventSourceMapping(ctx context.Context, params *GetEventSourceMappingInput, optFns ...func(*Options)) (*GetEventSourceMappingOutput, error) {
if params == nil {
params = &GetEventSourceMappingInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetEventSourceMapping", params, optFns, c.addOperationGetEventSourceMappingMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetEventSourceMappingOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetEventSourceMappingInput struct {
// The identifier of the event source mapping.
//
// This member is required.
UUID *string
noSmithyDocumentSerde
}
// A mapping between an Amazon Web Services resource and a Lambda function. For
// details, see CreateEventSourceMapping .
type GetEventSourceMappingOutput struct {
// Specific configuration settings for an Amazon Managed Streaming for Apache
// Kafka (Amazon MSK) event source.
AmazonManagedKafkaEventSourceConfig *types.AmazonManagedKafkaEventSourceConfig
// The maximum number of records in each batch that Lambda pulls from your stream
// or queue and sends to your function. Lambda passes all of the records in the
// batch to the function in a single call, up to the payload limit for synchronous
// invocation (6 MB). Default value: Varies by service. For Amazon SQS, the default
// is 10. For all other services, the default is 100. Related setting: When you set
// BatchSize to a value greater than 10, you must set
// MaximumBatchingWindowInSeconds to at least 1.
BatchSize *int32
// (Kinesis and DynamoDB Streams only) If the function returns an error, split the
// batch in two and retry. The default value is false.
BisectBatchOnFunctionError *bool
// (Kinesis and DynamoDB Streams only) An Amazon SQS queue or Amazon SNS topic
// destination for discarded records.
DestinationConfig *types.DestinationConfig
// Specific configuration settings for a DocumentDB event source.
DocumentDBEventSourceConfig *types.DocumentDBEventSourceConfig
// The Amazon Resource Name (ARN) of the event source.
EventSourceArn *string
// An object that defines the filter criteria that determine whether Lambda should
// process an event. For more information, see Lambda event filtering (https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html)
// .
FilterCriteria *types.FilterCriteria
// The ARN of the Lambda function.
FunctionArn *string
// (Kinesis, DynamoDB Streams, and Amazon SQS) A list of current response type
// enums applied to the event source mapping.
FunctionResponseTypes []types.FunctionResponseType
// The date that the event source mapping was last updated or that its state
// changed.
LastModified *time.Time
// The result of the last Lambda invocation of your function.
LastProcessingResult *string
// The maximum amount of time, in seconds, that Lambda spends gathering records
// before invoking the function. You can configure MaximumBatchingWindowInSeconds
// to any value from 0 seconds to 300 seconds in increments of seconds. For streams
// and Amazon SQS event sources, the default batching window is 0 seconds. For
// Amazon MSK, Self-managed Apache Kafka, Amazon MQ, and DocumentDB event sources,
// the default batching window is 500 ms. Note that because you can only change
// MaximumBatchingWindowInSeconds in increments of seconds, you cannot revert back
// to the 500 ms default batching window after you have changed it. To restore the
// default batching window, you must create a new event source mapping. Related
// setting: For streams and Amazon SQS event sources, when you set BatchSize to a
// value greater than 10, you must set MaximumBatchingWindowInSeconds to at least
// 1.
MaximumBatchingWindowInSeconds *int32
// (Kinesis and DynamoDB Streams only) Discard records older than the specified
// age. The default value is -1, which sets the maximum age to infinite. When the
// value is set to infinite, Lambda never discards old records. The minimum valid
// value for maximum record age is 60s. Although values less than 60 and greater
// than -1 fall within the parameter's absolute range, they are not allowed
MaximumRecordAgeInSeconds *int32
// (Kinesis and DynamoDB Streams only) Discard records after the specified number
// of retries. The default value is -1, which sets the maximum number of retries to
// infinite. When MaximumRetryAttempts is infinite, Lambda retries failed records
// until the record expires in the event source.
MaximumRetryAttempts *int32
// (Kinesis and DynamoDB Streams only) The number of batches to process
// concurrently from each shard. The default value is 1.
ParallelizationFactor *int32
// (Amazon MQ) The name of the Amazon MQ broker destination queue to consume.
Queues []string
// (Amazon SQS only) The scaling configuration for the event source. For more
// information, see Configuring maximum concurrency for Amazon SQS event sources (https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#events-sqs-max-concurrency)
// .
ScalingConfig *types.ScalingConfig
// The self-managed Apache Kafka cluster for your event source.
SelfManagedEventSource *types.SelfManagedEventSource
// Specific configuration settings for a self-managed Apache Kafka event source.
SelfManagedKafkaEventSourceConfig *types.SelfManagedKafkaEventSourceConfig
// An array of the authentication protocol, VPC components, or virtual host to
// secure and define your event source.
SourceAccessConfigurations []types.SourceAccessConfiguration
// The position in a stream from which to start reading. Required for Amazon
// Kinesis and Amazon DynamoDB Stream event sources. AT_TIMESTAMP is supported
// only for Amazon Kinesis streams, Amazon DocumentDB, Amazon MSK, and self-managed
// Apache Kafka.
StartingPosition types.EventSourcePosition
// With StartingPosition set to AT_TIMESTAMP , the time from which to start
// reading. StartingPositionTimestamp cannot be in the future.
StartingPositionTimestamp *time.Time
// The state of the event source mapping. It can be one of the following: Creating
// , Enabling , Enabled , Disabling , Disabled , Updating , or Deleting .
State *string
// Indicates whether a user or Lambda made the last change to the event source
// mapping.
StateTransitionReason *string
// The name of the Kafka topic.
Topics []string
// (Kinesis and DynamoDB Streams only) The duration in seconds of a processing
// window for DynamoDB and Kinesis Streams event sources. A value of 0 seconds
// indicates no tumbling window.
TumblingWindowInSeconds *int32
// The identifier of the event source mapping.
UUID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetEventSourceMappingMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetEventSourceMapping{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetEventSourceMapping{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetEventSourceMappingValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetEventSourceMapping(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetEventSourceMapping(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetEventSourceMapping",
}
}
| 250 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
"errors"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Returns information about the function or function version, with a link to
// download the deployment package that's valid for 10 minutes. If you specify a
// function version, only details that are specific to that version are returned.
func (c *Client) GetFunction(ctx context.Context, params *GetFunctionInput, optFns ...func(*Options)) (*GetFunctionOutput, error) {
if params == nil {
params = &GetFunctionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetFunction", params, optFns, c.addOperationGetFunctionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetFunctionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetFunctionInput struct {
// The name of the Lambda function, version, or alias. Name formats
// - Function name – my-function (name-only), my-function:v1 (with alias).
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// You can append a version number or alias to any of the formats. The length
// constraint applies only to the full ARN. If you specify only the function name,
// it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Specify a version or alias to get details about a published version of the
// function.
Qualifier *string
noSmithyDocumentSerde
}
type GetFunctionOutput struct {
// The deployment package of the function or version.
Code *types.FunctionCodeLocation
// The function's reserved concurrency (https://docs.aws.amazon.com/lambda/latest/dg/concurrent-executions.html)
// .
Concurrency *types.Concurrency
// The configuration of the function or version.
Configuration *types.FunctionConfiguration
// The function's tags (https://docs.aws.amazon.com/lambda/latest/dg/tagging.html) .
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetFunctionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetFunction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetFunction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetFunctionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetFunction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// GetFunctionAPIClient is a client that implements the GetFunction operation.
type GetFunctionAPIClient interface {
GetFunction(context.Context, *GetFunctionInput, ...func(*Options)) (*GetFunctionOutput, error)
}
var _ GetFunctionAPIClient = (*Client)(nil)
// FunctionActiveV2WaiterOptions are waiter options for FunctionActiveV2Waiter
type FunctionActiveV2WaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// FunctionActiveV2Waiter will use default minimum delay of 1 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, FunctionActiveV2Waiter will use default max delay of 120 seconds.
// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetFunctionInput, *GetFunctionOutput, error) (bool, error)
}
// FunctionActiveV2Waiter defines the waiters for FunctionActiveV2
type FunctionActiveV2Waiter struct {
client GetFunctionAPIClient
options FunctionActiveV2WaiterOptions
}
// NewFunctionActiveV2Waiter constructs a FunctionActiveV2Waiter.
func NewFunctionActiveV2Waiter(client GetFunctionAPIClient, optFns ...func(*FunctionActiveV2WaiterOptions)) *FunctionActiveV2Waiter {
options := FunctionActiveV2WaiterOptions{}
options.MinDelay = 1 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = functionActiveV2StateRetryable
for _, fn := range optFns {
fn(&options)
}
return &FunctionActiveV2Waiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for FunctionActiveV2 waiter. The maxWaitDur is
// the maximum wait duration the waiter will wait. The maxWaitDur is required and
// must be greater than zero.
func (w *FunctionActiveV2Waiter) Wait(ctx context.Context, params *GetFunctionInput, maxWaitDur time.Duration, optFns ...func(*FunctionActiveV2WaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for FunctionActiveV2 waiter and returns
// the output of the successful operation. The maxWaitDur is the maximum wait
// duration the waiter will wait. The maxWaitDur is required and must be greater
// than zero.
func (w *FunctionActiveV2Waiter) WaitForOutput(ctx context.Context, params *GetFunctionInput, maxWaitDur time.Duration, optFns ...func(*FunctionActiveV2WaiterOptions)) (*GetFunctionOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetFunction(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for FunctionActiveV2 waiter")
}
func functionActiveV2StateRetryable(ctx context.Context, input *GetFunctionInput, output *GetFunctionOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("Configuration.State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Active"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("Configuration.State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Failed"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("Configuration.State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Pending"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
return true, nil
}
// FunctionExistsWaiterOptions are waiter options for FunctionExistsWaiter
type FunctionExistsWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// FunctionExistsWaiter will use default minimum delay of 1 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, FunctionExistsWaiter will use default max delay of 120 seconds.
// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetFunctionInput, *GetFunctionOutput, error) (bool, error)
}
// FunctionExistsWaiter defines the waiters for FunctionExists
type FunctionExistsWaiter struct {
client GetFunctionAPIClient
options FunctionExistsWaiterOptions
}
// NewFunctionExistsWaiter constructs a FunctionExistsWaiter.
func NewFunctionExistsWaiter(client GetFunctionAPIClient, optFns ...func(*FunctionExistsWaiterOptions)) *FunctionExistsWaiter {
options := FunctionExistsWaiterOptions{}
options.MinDelay = 1 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = functionExistsStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &FunctionExistsWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for FunctionExists waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *FunctionExistsWaiter) Wait(ctx context.Context, params *GetFunctionInput, maxWaitDur time.Duration, optFns ...func(*FunctionExistsWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for FunctionExists waiter and returns
// the output of the successful operation. The maxWaitDur is the maximum wait
// duration the waiter will wait. The maxWaitDur is required and must be greater
// than zero.
func (w *FunctionExistsWaiter) WaitForOutput(ctx context.Context, params *GetFunctionInput, maxWaitDur time.Duration, optFns ...func(*FunctionExistsWaiterOptions)) (*GetFunctionOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetFunction(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for FunctionExists waiter")
}
func functionExistsStateRetryable(ctx context.Context, input *GetFunctionInput, output *GetFunctionOutput, err error) (bool, error) {
if err == nil {
return false, nil
}
if err != nil {
var errorType *types.ResourceNotFoundException
if errors.As(err, &errorType) {
return true, nil
}
}
return true, nil
}
// FunctionUpdatedV2WaiterOptions are waiter options for FunctionUpdatedV2Waiter
type FunctionUpdatedV2WaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// FunctionUpdatedV2Waiter will use default minimum delay of 1 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, FunctionUpdatedV2Waiter will use default max delay of 120 seconds.
// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetFunctionInput, *GetFunctionOutput, error) (bool, error)
}
// FunctionUpdatedV2Waiter defines the waiters for FunctionUpdatedV2
type FunctionUpdatedV2Waiter struct {
client GetFunctionAPIClient
options FunctionUpdatedV2WaiterOptions
}
// NewFunctionUpdatedV2Waiter constructs a FunctionUpdatedV2Waiter.
func NewFunctionUpdatedV2Waiter(client GetFunctionAPIClient, optFns ...func(*FunctionUpdatedV2WaiterOptions)) *FunctionUpdatedV2Waiter {
options := FunctionUpdatedV2WaiterOptions{}
options.MinDelay = 1 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = functionUpdatedV2StateRetryable
for _, fn := range optFns {
fn(&options)
}
return &FunctionUpdatedV2Waiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for FunctionUpdatedV2 waiter. The maxWaitDur is
// the maximum wait duration the waiter will wait. The maxWaitDur is required and
// must be greater than zero.
func (w *FunctionUpdatedV2Waiter) Wait(ctx context.Context, params *GetFunctionInput, maxWaitDur time.Duration, optFns ...func(*FunctionUpdatedV2WaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for FunctionUpdatedV2 waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *FunctionUpdatedV2Waiter) WaitForOutput(ctx context.Context, params *GetFunctionInput, maxWaitDur time.Duration, optFns ...func(*FunctionUpdatedV2WaiterOptions)) (*GetFunctionOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetFunction(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for FunctionUpdatedV2 waiter")
}
func functionUpdatedV2StateRetryable(ctx context.Context, input *GetFunctionInput, output *GetFunctionOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("Configuration.LastUpdateStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Successful"
value, ok := pathValue.(types.LastUpdateStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LastUpdateStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("Configuration.LastUpdateStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Failed"
value, ok := pathValue.(types.LastUpdateStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LastUpdateStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("Configuration.LastUpdateStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "InProgress"
value, ok := pathValue.(types.LastUpdateStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LastUpdateStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetFunction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetFunction",
}
}
| 702 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the code signing configuration for the specified function.
func (c *Client) GetFunctionCodeSigningConfig(ctx context.Context, params *GetFunctionCodeSigningConfigInput, optFns ...func(*Options)) (*GetFunctionCodeSigningConfigOutput, error) {
if params == nil {
params = &GetFunctionCodeSigningConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetFunctionCodeSigningConfig", params, optFns, c.addOperationGetFunctionCodeSigningConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetFunctionCodeSigningConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetFunctionCodeSigningConfigInput struct {
// The name of the Lambda function. Name formats
// - Function name - MyFunction .
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction .
// - Partial ARN - 123456789012:function:MyFunction .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
noSmithyDocumentSerde
}
type GetFunctionCodeSigningConfigOutput struct {
// The The Amazon Resource Name (ARN) of the code signing configuration.
//
// This member is required.
CodeSigningConfigArn *string
// The name of the Lambda function. Name formats
// - Function name - MyFunction .
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction .
// - Partial ARN - 123456789012:function:MyFunction .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetFunctionCodeSigningConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetFunctionCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetFunctionCodeSigningConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetFunctionCodeSigningConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetFunctionCodeSigningConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetFunctionCodeSigningConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetFunctionCodeSigningConfig",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns details about the reserved concurrency configuration for a function. To
// set a concurrency limit for a function, use PutFunctionConcurrency .
func (c *Client) GetFunctionConcurrency(ctx context.Context, params *GetFunctionConcurrencyInput, optFns ...func(*Options)) (*GetFunctionConcurrencyOutput, error) {
if params == nil {
params = &GetFunctionConcurrencyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetFunctionConcurrency", params, optFns, c.addOperationGetFunctionConcurrencyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetFunctionConcurrencyOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetFunctionConcurrencyInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
noSmithyDocumentSerde
}
type GetFunctionConcurrencyOutput struct {
// The number of simultaneous executions that are reserved for the function.
ReservedConcurrentExecutions *int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetFunctionConcurrencyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetFunctionConcurrency{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetFunctionConcurrency{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetFunctionConcurrencyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetFunctionConcurrency(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetFunctionConcurrency(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetFunctionConcurrency",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Returns the version-specific settings of a Lambda function or version. The
// output includes only options that can vary between versions of a function. To
// modify these settings, use UpdateFunctionConfiguration . To get all of a
// function's details, including function-level settings, use GetFunction .
func (c *Client) GetFunctionConfiguration(ctx context.Context, params *GetFunctionConfigurationInput, optFns ...func(*Options)) (*GetFunctionConfigurationOutput, error) {
if params == nil {
params = &GetFunctionConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetFunctionConfiguration", params, optFns, c.addOperationGetFunctionConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetFunctionConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetFunctionConfigurationInput struct {
// The name of the Lambda function, version, or alias. Name formats
// - Function name – my-function (name-only), my-function:v1 (with alias).
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// You can append a version number or alias to any of the formats. The length
// constraint applies only to the full ARN. If you specify only the function name,
// it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Specify a version or alias to get details about a published version of the
// function.
Qualifier *string
noSmithyDocumentSerde
}
// Details about a function's configuration.
type GetFunctionConfigurationOutput struct {
// The instruction set architecture that the function supports. Architecture is a
// string array with one of the valid values. The default architecture value is
// x86_64 .
Architectures []types.Architecture
// The SHA256 hash of the function's deployment package.
CodeSha256 *string
// The size of the function's deployment package, in bytes.
CodeSize int64
// The function's dead letter queue.
DeadLetterConfig *types.DeadLetterConfig
// The function's description.
Description *string
// The function's environment variables (https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html)
// . Omitted from CloudTrail logs.
Environment *types.EnvironmentResponse
// The size of the function’s /tmp directory in MB. The default value is 512, but
// it can be any whole number between 512 and 10,240 MB.
EphemeralStorage *types.EphemeralStorage
// Connection settings for an Amazon EFS file system (https://docs.aws.amazon.com/lambda/latest/dg/configuration-filesystem.html)
// .
FileSystemConfigs []types.FileSystemConfig
// The function's Amazon Resource Name (ARN).
FunctionArn *string
// The name of the function.
FunctionName *string
// The function that Lambda calls to begin running your function.
Handler *string
// The function's image configuration values.
ImageConfigResponse *types.ImageConfigResponse
// The KMS key that's used to encrypt the function's environment variables (https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-encryption)
// . When Lambda SnapStart (https://docs.aws.amazon.com/lambda/latest/dg/snapstart-security.html)
// is activated, this key is also used to encrypt the function's snapshot. This key
// is returned only if you've configured a customer managed key.
KMSKeyArn *string
// The date and time that the function was last updated, in ISO-8601 format (https://www.w3.org/TR/NOTE-datetime)
// (YYYY-MM-DDThh:mm:ss.sTZD).
LastModified *string
// The status of the last update that was performed on the function. This is first
// set to Successful after function creation completes.
LastUpdateStatus types.LastUpdateStatus
// The reason for the last update that was performed on the function.
LastUpdateStatusReason *string
// The reason code for the last update that was performed on the function.
LastUpdateStatusReasonCode types.LastUpdateStatusReasonCode
// The function's layers (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// .
Layers []types.Layer
// For Lambda@Edge functions, the ARN of the main function.
MasterArn *string
// The amount of memory available to the function at runtime.
MemorySize *int32
// The type of deployment package. Set to Image for container image and set Zip
// for .zip file archive.
PackageType types.PackageType
// The latest updated revision of the function or alias.
RevisionId *string
// The function's execution role.
Role *string
// The identifier of the function's runtime (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html)
// . Runtime is required if the deployment package is a .zip file archive. The
// following list includes deprecated runtimes. For more information, see Runtime
// deprecation policy (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-support-policy)
// .
Runtime types.Runtime
// The ARN of the runtime and any errors that occured.
RuntimeVersionConfig *types.RuntimeVersionConfig
// The ARN of the signing job.
SigningJobArn *string
// The ARN of the signing profile version.
SigningProfileVersionArn *string
// Set ApplyOn to PublishedVersions to create a snapshot of the initialized
// execution environment when you publish a function version. For more information,
// see Improving startup performance with Lambda SnapStart (https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html)
// .
SnapStart *types.SnapStartResponse
// The current state of the function. When the state is Inactive , you can
// reactivate the function by invoking it.
State types.State
// The reason for the function's current state.
StateReason *string
// The reason code for the function's current state. When the code is Creating ,
// you can't invoke or modify the function.
StateReasonCode types.StateReasonCode
// The amount of time in seconds that Lambda allows a function to run before
// stopping it.
Timeout *int32
// The function's X-Ray tracing configuration.
TracingConfig *types.TracingConfigResponse
// The version of the Lambda function.
Version *string
// The function's networking configuration.
VpcConfig *types.VpcConfigResponse
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetFunctionConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetFunctionConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetFunctionConfiguration{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetFunctionConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetFunctionConfiguration(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// GetFunctionConfigurationAPIClient is a client that implements the
// GetFunctionConfiguration operation.
type GetFunctionConfigurationAPIClient interface {
GetFunctionConfiguration(context.Context, *GetFunctionConfigurationInput, ...func(*Options)) (*GetFunctionConfigurationOutput, error)
}
var _ GetFunctionConfigurationAPIClient = (*Client)(nil)
// FunctionActiveWaiterOptions are waiter options for FunctionActiveWaiter
type FunctionActiveWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// FunctionActiveWaiter will use default minimum delay of 5 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, FunctionActiveWaiter will use default max delay of 120 seconds.
// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetFunctionConfigurationInput, *GetFunctionConfigurationOutput, error) (bool, error)
}
// FunctionActiveWaiter defines the waiters for FunctionActive
type FunctionActiveWaiter struct {
client GetFunctionConfigurationAPIClient
options FunctionActiveWaiterOptions
}
// NewFunctionActiveWaiter constructs a FunctionActiveWaiter.
func NewFunctionActiveWaiter(client GetFunctionConfigurationAPIClient, optFns ...func(*FunctionActiveWaiterOptions)) *FunctionActiveWaiter {
options := FunctionActiveWaiterOptions{}
options.MinDelay = 5 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = functionActiveStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &FunctionActiveWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for FunctionActive waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *FunctionActiveWaiter) Wait(ctx context.Context, params *GetFunctionConfigurationInput, maxWaitDur time.Duration, optFns ...func(*FunctionActiveWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for FunctionActive waiter and returns
// the output of the successful operation. The maxWaitDur is the maximum wait
// duration the waiter will wait. The maxWaitDur is required and must be greater
// than zero.
func (w *FunctionActiveWaiter) WaitForOutput(ctx context.Context, params *GetFunctionConfigurationInput, maxWaitDur time.Duration, optFns ...func(*FunctionActiveWaiterOptions)) (*GetFunctionConfigurationOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetFunctionConfiguration(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for FunctionActive waiter")
}
func functionActiveStateRetryable(ctx context.Context, input *GetFunctionConfigurationInput, output *GetFunctionConfigurationOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Active"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Failed"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Pending"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
return true, nil
}
// FunctionUpdatedWaiterOptions are waiter options for FunctionUpdatedWaiter
type FunctionUpdatedWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// FunctionUpdatedWaiter will use default minimum delay of 5 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, FunctionUpdatedWaiter will use default max delay of 120 seconds.
// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetFunctionConfigurationInput, *GetFunctionConfigurationOutput, error) (bool, error)
}
// FunctionUpdatedWaiter defines the waiters for FunctionUpdated
type FunctionUpdatedWaiter struct {
client GetFunctionConfigurationAPIClient
options FunctionUpdatedWaiterOptions
}
// NewFunctionUpdatedWaiter constructs a FunctionUpdatedWaiter.
func NewFunctionUpdatedWaiter(client GetFunctionConfigurationAPIClient, optFns ...func(*FunctionUpdatedWaiterOptions)) *FunctionUpdatedWaiter {
options := FunctionUpdatedWaiterOptions{}
options.MinDelay = 5 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = functionUpdatedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &FunctionUpdatedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for FunctionUpdated waiter. The maxWaitDur is
// the maximum wait duration the waiter will wait. The maxWaitDur is required and
// must be greater than zero.
func (w *FunctionUpdatedWaiter) Wait(ctx context.Context, params *GetFunctionConfigurationInput, maxWaitDur time.Duration, optFns ...func(*FunctionUpdatedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for FunctionUpdated waiter and returns
// the output of the successful operation. The maxWaitDur is the maximum wait
// duration the waiter will wait. The maxWaitDur is required and must be greater
// than zero.
func (w *FunctionUpdatedWaiter) WaitForOutput(ctx context.Context, params *GetFunctionConfigurationInput, maxWaitDur time.Duration, optFns ...func(*FunctionUpdatedWaiterOptions)) (*GetFunctionConfigurationOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetFunctionConfiguration(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for FunctionUpdated waiter")
}
func functionUpdatedStateRetryable(ctx context.Context, input *GetFunctionConfigurationInput, output *GetFunctionConfigurationOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("LastUpdateStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Successful"
value, ok := pathValue.(types.LastUpdateStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LastUpdateStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("LastUpdateStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Failed"
value, ok := pathValue.(types.LastUpdateStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LastUpdateStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("LastUpdateStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "InProgress"
value, ok := pathValue.(types.LastUpdateStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LastUpdateStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
return true, nil
}
// PublishedVersionActiveWaiterOptions are waiter options for
// PublishedVersionActiveWaiter
type PublishedVersionActiveWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// PublishedVersionActiveWaiter will use default minimum delay of 5 seconds. Note
// that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, PublishedVersionActiveWaiter will use default max delay of 120
// seconds. Note that MaxDelay must resolve to value greater than or equal to the
// MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetFunctionConfigurationInput, *GetFunctionConfigurationOutput, error) (bool, error)
}
// PublishedVersionActiveWaiter defines the waiters for PublishedVersionActive
type PublishedVersionActiveWaiter struct {
client GetFunctionConfigurationAPIClient
options PublishedVersionActiveWaiterOptions
}
// NewPublishedVersionActiveWaiter constructs a PublishedVersionActiveWaiter.
func NewPublishedVersionActiveWaiter(client GetFunctionConfigurationAPIClient, optFns ...func(*PublishedVersionActiveWaiterOptions)) *PublishedVersionActiveWaiter {
options := PublishedVersionActiveWaiterOptions{}
options.MinDelay = 5 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = publishedVersionActiveStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &PublishedVersionActiveWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for PublishedVersionActive waiter. The
// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is
// required and must be greater than zero.
func (w *PublishedVersionActiveWaiter) Wait(ctx context.Context, params *GetFunctionConfigurationInput, maxWaitDur time.Duration, optFns ...func(*PublishedVersionActiveWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for PublishedVersionActive waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *PublishedVersionActiveWaiter) WaitForOutput(ctx context.Context, params *GetFunctionConfigurationInput, maxWaitDur time.Duration, optFns ...func(*PublishedVersionActiveWaiterOptions)) (*GetFunctionConfigurationOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetFunctionConfiguration(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for PublishedVersionActive waiter")
}
func publishedVersionActiveStateRetryable(ctx context.Context, input *GetFunctionConfigurationInput, output *GetFunctionConfigurationOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Active"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Failed"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("State", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Pending"
value, ok := pathValue.(types.State)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.State value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetFunctionConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetFunctionConfiguration",
}
}
| 860 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Retrieves the configuration for asynchronous invocation for a function,
// version, or alias. To configure options for asynchronous invocation, use
// PutFunctionEventInvokeConfig .
func (c *Client) GetFunctionEventInvokeConfig(ctx context.Context, params *GetFunctionEventInvokeConfigInput, optFns ...func(*Options)) (*GetFunctionEventInvokeConfigOutput, error) {
if params == nil {
params = &GetFunctionEventInvokeConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetFunctionEventInvokeConfig", params, optFns, c.addOperationGetFunctionEventInvokeConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetFunctionEventInvokeConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetFunctionEventInvokeConfigInput struct {
// The name of the Lambda function, version, or alias. Name formats
// - Function name - my-function (name-only), my-function:v1 (with alias).
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN - 123456789012:function:my-function .
// You can append a version number or alias to any of the formats. The length
// constraint applies only to the full ARN. If you specify only the function name,
// it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// A version number or alias name.
Qualifier *string
noSmithyDocumentSerde
}
type GetFunctionEventInvokeConfigOutput struct {
// A destination for events after they have been sent to a function for
// processing. Destinations
// - Function - The Amazon Resource Name (ARN) of a Lambda function.
// - Queue - The ARN of a standard SQS queue.
// - Topic - The ARN of a standard SNS topic.
// - Event Bus - The ARN of an Amazon EventBridge event bus.
DestinationConfig *types.DestinationConfig
// The Amazon Resource Name (ARN) of the function.
FunctionArn *string
// The date and time that the configuration was last updated.
LastModified *time.Time
// The maximum age of a request that Lambda sends to a function for processing.
MaximumEventAgeInSeconds *int32
// The maximum number of times to retry when the function returns an error.
MaximumRetryAttempts *int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetFunctionEventInvokeConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetFunctionEventInvokeConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetFunctionEventInvokeConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetFunctionEventInvokeConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetFunctionEventInvokeConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetFunctionEventInvokeConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetFunctionEventInvokeConfig",
}
}
| 154 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns details about a Lambda function URL.
func (c *Client) GetFunctionUrlConfig(ctx context.Context, params *GetFunctionUrlConfigInput, optFns ...func(*Options)) (*GetFunctionUrlConfigOutput, error) {
if params == nil {
params = &GetFunctionUrlConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetFunctionUrlConfig", params, optFns, c.addOperationGetFunctionUrlConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetFunctionUrlConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetFunctionUrlConfigInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The alias name.
Qualifier *string
noSmithyDocumentSerde
}
type GetFunctionUrlConfigOutput struct {
// The type of authentication that your function URL uses. Set to AWS_IAM if you
// want to restrict access to authenticated users only. Set to NONE if you want to
// bypass IAM authentication to create a public endpoint. For more information, see
// Security and auth model for Lambda function URLs (https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html)
// .
//
// This member is required.
AuthType types.FunctionUrlAuthType
// When the function URL was created, in ISO-8601 format (https://www.w3.org/TR/NOTE-datetime)
// (YYYY-MM-DDThh:mm:ss.sTZD).
//
// This member is required.
CreationTime *string
// The Amazon Resource Name (ARN) of your function.
//
// This member is required.
FunctionArn *string
// The HTTP URL endpoint for your function.
//
// This member is required.
FunctionUrl *string
// When the function URL configuration was last updated, in ISO-8601 format (https://www.w3.org/TR/NOTE-datetime)
// (YYYY-MM-DDThh:mm:ss.sTZD).
//
// This member is required.
LastModifiedTime *string
// The cross-origin resource sharing (CORS) (https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)
// settings for your function URL.
Cors *types.Cors
// Use one of the following options:
// - BUFFERED – This is the default option. Lambda invokes your function using
// the Invoke API operation. Invocation results are available when the payload is
// complete. The maximum payload size is 6 MB.
// - RESPONSE_STREAM – Your function streams payload results as they become
// available. Lambda invokes your function using the InvokeWithResponseStream API
// operation. The maximum response payload size is 20 MB, however, you can
// request a quota increase (https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html)
// .
InvokeMode types.InvokeMode
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetFunctionUrlConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetFunctionUrlConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetFunctionUrlConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetFunctionUrlConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetFunctionUrlConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetFunctionUrlConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetFunctionUrlConfig",
}
}
| 176 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a version of an Lambda layer (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// , with a link to download the layer archive that's valid for 10 minutes.
func (c *Client) GetLayerVersion(ctx context.Context, params *GetLayerVersionInput, optFns ...func(*Options)) (*GetLayerVersionOutput, error) {
if params == nil {
params = &GetLayerVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLayerVersion", params, optFns, c.addOperationGetLayerVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLayerVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLayerVersionInput struct {
// The name or Amazon Resource Name (ARN) of the layer.
//
// This member is required.
LayerName *string
// The version number.
//
// This member is required.
VersionNumber int64
noSmithyDocumentSerde
}
type GetLayerVersionOutput struct {
// A list of compatible instruction set architectures (https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html)
// .
CompatibleArchitectures []types.Architecture
// The layer's compatible runtimes. The following list includes deprecated
// runtimes. For more information, see Runtime deprecation policy (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-support-policy)
// .
CompatibleRuntimes []types.Runtime
// Details about the layer version.
Content *types.LayerVersionContentOutput
// The date that the layer version was created, in ISO-8601 format (https://www.w3.org/TR/NOTE-datetime)
// (YYYY-MM-DDThh:mm:ss.sTZD).
CreatedDate *string
// The description of the version.
Description *string
// The ARN of the layer.
LayerArn *string
// The ARN of the layer version.
LayerVersionArn *string
// The layer's software license.
LicenseInfo *string
// The version number.
Version int64
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLayerVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLayerVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLayerVersion{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetLayerVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLayerVersion(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetLayerVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetLayerVersion",
}
}
| 159 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a version of an Lambda layer (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// , with a link to download the layer archive that's valid for 10 minutes.
func (c *Client) GetLayerVersionByArn(ctx context.Context, params *GetLayerVersionByArnInput, optFns ...func(*Options)) (*GetLayerVersionByArnOutput, error) {
if params == nil {
params = &GetLayerVersionByArnInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLayerVersionByArn", params, optFns, c.addOperationGetLayerVersionByArnMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLayerVersionByArnOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLayerVersionByArnInput struct {
// The ARN of the layer version.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type GetLayerVersionByArnOutput struct {
// A list of compatible instruction set architectures (https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html)
// .
CompatibleArchitectures []types.Architecture
// The layer's compatible runtimes. The following list includes deprecated
// runtimes. For more information, see Runtime deprecation policy (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-support-policy)
// .
CompatibleRuntimes []types.Runtime
// Details about the layer version.
Content *types.LayerVersionContentOutput
// The date that the layer version was created, in ISO-8601 format (https://www.w3.org/TR/NOTE-datetime)
// (YYYY-MM-DDThh:mm:ss.sTZD).
CreatedDate *string
// The description of the version.
Description *string
// The ARN of the layer.
LayerArn *string
// The ARN of the layer version.
LayerVersionArn *string
// The layer's software license.
LicenseInfo *string
// The version number.
Version int64
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLayerVersionByArnMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLayerVersionByArn{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLayerVersionByArn{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetLayerVersionByArnValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLayerVersionByArn(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetLayerVersionByArn(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetLayerVersionByArn",
}
}
| 154 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the permission policy for a version of an Lambda layer (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// . For more information, see AddLayerVersionPermission .
func (c *Client) GetLayerVersionPolicy(ctx context.Context, params *GetLayerVersionPolicyInput, optFns ...func(*Options)) (*GetLayerVersionPolicyOutput, error) {
if params == nil {
params = &GetLayerVersionPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLayerVersionPolicy", params, optFns, c.addOperationGetLayerVersionPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLayerVersionPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLayerVersionPolicyInput struct {
// The name or Amazon Resource Name (ARN) of the layer.
//
// This member is required.
LayerName *string
// The version number.
//
// This member is required.
VersionNumber int64
noSmithyDocumentSerde
}
type GetLayerVersionPolicyOutput struct {
// The policy document.
Policy *string
// A unique identifier for the current revision of the policy.
RevisionId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLayerVersionPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLayerVersionPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLayerVersionPolicy{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetLayerVersionPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLayerVersionPolicy(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetLayerVersionPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetLayerVersionPolicy",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the resource-based IAM policy (https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html)
// for a function, version, or alias.
func (c *Client) GetPolicy(ctx context.Context, params *GetPolicyInput, optFns ...func(*Options)) (*GetPolicyOutput, error) {
if params == nil {
params = &GetPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetPolicy", params, optFns, c.addOperationGetPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetPolicyInput struct {
// The name of the Lambda function, version, or alias. Name formats
// - Function name – my-function (name-only), my-function:v1 (with alias).
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// You can append a version number or alias to any of the formats. The length
// constraint applies only to the full ARN. If you specify only the function name,
// it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Specify a version or alias to get the policy for that resource.
Qualifier *string
noSmithyDocumentSerde
}
type GetPolicyOutput struct {
// The resource-based policy.
Policy *string
// A unique identifier for the current revision of the policy.
RevisionId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetPolicy{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetPolicy(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetPolicy",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the provisioned concurrency configuration for a function's alias or
// version.
func (c *Client) GetProvisionedConcurrencyConfig(ctx context.Context, params *GetProvisionedConcurrencyConfigInput, optFns ...func(*Options)) (*GetProvisionedConcurrencyConfigOutput, error) {
if params == nil {
params = &GetProvisionedConcurrencyConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetProvisionedConcurrencyConfig", params, optFns, c.addOperationGetProvisionedConcurrencyConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetProvisionedConcurrencyConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetProvisionedConcurrencyConfigInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The version number or alias name.
//
// This member is required.
Qualifier *string
noSmithyDocumentSerde
}
type GetProvisionedConcurrencyConfigOutput struct {
// The amount of provisioned concurrency allocated. When a weighted alias is used
// during linear and canary deployments, this value fluctuates depending on the
// amount of concurrency that is provisioned for the function versions.
AllocatedProvisionedConcurrentExecutions *int32
// The amount of provisioned concurrency available.
AvailableProvisionedConcurrentExecutions *int32
// The date and time that a user last updated the configuration, in ISO 8601 format (https://www.iso.org/iso-8601-date-and-time-format.html)
// .
LastModified *string
// The amount of provisioned concurrency requested.
RequestedProvisionedConcurrentExecutions *int32
// The status of the allocation process.
Status types.ProvisionedConcurrencyStatusEnum
// For failed allocations, the reason that provisioned concurrency could not be
// allocated.
StatusReason *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetProvisionedConcurrencyConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetProvisionedConcurrencyConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetProvisionedConcurrencyConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetProvisionedConcurrencyConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetProvisionedConcurrencyConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetProvisionedConcurrencyConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetProvisionedConcurrencyConfig",
}
}
| 155 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the runtime management configuration for a function's version. If the
// runtime update mode is Manual, this includes the ARN of the runtime version and
// the runtime update mode. If the runtime update mode is Auto or Function update,
// this includes the runtime update mode and null is returned for the ARN. For
// more information, see Runtime updates (https://docs.aws.amazon.com/lambda/latest/dg/runtimes-update.html)
// .
func (c *Client) GetRuntimeManagementConfig(ctx context.Context, params *GetRuntimeManagementConfigInput, optFns ...func(*Options)) (*GetRuntimeManagementConfigOutput, error) {
if params == nil {
params = &GetRuntimeManagementConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetRuntimeManagementConfig", params, optFns, c.addOperationGetRuntimeManagementConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetRuntimeManagementConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetRuntimeManagementConfigInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Specify a version of the function. This can be $LATEST or a published version
// number. If no value is specified, the configuration for the $LATEST version is
// returned.
Qualifier *string
noSmithyDocumentSerde
}
type GetRuntimeManagementConfigOutput struct {
// The Amazon Resource Name (ARN) of your function.
FunctionArn *string
// The ARN of the runtime the function is configured to use. If the runtime update
// mode is Manual, the ARN is returned, otherwise null is returned.
RuntimeVersionArn *string
// The current runtime update mode of the function.
UpdateRuntimeOn types.UpdateRuntimeOn
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetRuntimeManagementConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetRuntimeManagementConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetRuntimeManagementConfig{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetRuntimeManagementConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetRuntimeManagementConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetRuntimeManagementConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "GetRuntimeManagementConfig",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Invokes a Lambda function. You can invoke a function synchronously (and wait
// for the response), or asynchronously. To invoke a function asynchronously, set
// InvocationType to Event . For synchronous invocation (https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html)
// , details about the function response, including errors, are included in the
// response body and headers. For either invocation type, you can find more
// information in the execution log (https://docs.aws.amazon.com/lambda/latest/dg/monitoring-functions.html)
// and trace (https://docs.aws.amazon.com/lambda/latest/dg/lambda-x-ray.html) .
// When an error occurs, your function may be invoked multiple times. Retry
// behavior varies by error type, client, event source, and invocation type. For
// example, if you invoke a function asynchronously and it returns an error, Lambda
// executes the function up to two more times. For more information, see Error
// handling and automatic retries in Lambda (https://docs.aws.amazon.com/lambda/latest/dg/invocation-retries.html)
// . For asynchronous invocation (https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html)
// , Lambda adds events to a queue before sending them to your function. If your
// function does not have enough capacity to keep up with the queue, events may be
// lost. Occasionally, your function may receive the same event multiple times,
// even if no error occurs. To retain events that were not processed, configure
// your function with a dead-letter queue (https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#invocation-dlq)
// . The status code in the API response doesn't reflect function errors. Error
// codes are reserved for errors that prevent your function from executing, such as
// permissions errors, quota (https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html)
// errors, or issues with your function's code and configuration. For example,
// Lambda returns TooManyRequestsException if running the function would cause you
// to exceed a concurrency limit at either the account level (
// ConcurrentInvocationLimitExceeded ) or function level (
// ReservedFunctionConcurrentInvocationLimitExceeded ). For functions with a long
// timeout, your client might disconnect during synchronous invocation while it
// waits for a response. Configure your HTTP client, SDK, firewall, proxy, or
// operating system to allow for long connections with timeout or keep-alive
// settings. This operation requires permission for the lambda:InvokeFunction (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awslambda.html)
// action. For details on how to set up permissions for cross-account invocations,
// see Granting function access to other accounts (https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html#permissions-resource-xaccountinvoke)
// .
func (c *Client) Invoke(ctx context.Context, params *InvokeInput, optFns ...func(*Options)) (*InvokeOutput, error) {
if params == nil {
params = &InvokeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "Invoke", params, optFns, c.addOperationInvokeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*InvokeOutput)
out.ResultMetadata = metadata
return out, nil
}
type InvokeInput struct {
// The name of the Lambda function, version, or alias. Name formats
// - Function name – my-function (name-only), my-function:v1 (with alias).
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// You can append a version number or alias to any of the formats. The length
// constraint applies only to the full ARN. If you specify only the function name,
// it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Up to 3,583 bytes of base64-encoded data about the invoking client to pass to
// the function in the context object.
ClientContext *string
// Choose from the following options.
// - RequestResponse (default) – Invoke the function synchronously. Keep the
// connection open until the function returns a response or times out. The API
// response includes the function response and additional data.
// - Event – Invoke the function asynchronously. Send events that fail multiple
// times to the function's dead-letter queue (if one is configured). The API
// response only includes a status code.
// - DryRun – Validate parameter values and verify that the user or role has
// permission to invoke the function.
InvocationType types.InvocationType
// Set to Tail to include the execution log in the response. Applies to
// synchronously invoked functions only.
LogType types.LogType
// The JSON that you want to provide to your Lambda function as input. You can
// enter the JSON directly. For example, --payload '{ "key": "value" }' . You can
// also specify a file path. For example, --payload file://payload.json .
Payload []byte
// Specify a version or alias to invoke a published version of the function.
Qualifier *string
noSmithyDocumentSerde
}
type InvokeOutput struct {
// The version of the function that executed. When you invoke a function with an
// alias, this indicates which version the alias resolved to.
ExecutedVersion *string
// If present, indicates that an error occurred during function execution. Details
// about the error are included in the response payload.
FunctionError *string
// The last 4 KB of the execution log, which is base64-encoded.
LogResult *string
// The response from the function, or an error object.
Payload []byte
// The HTTP status code is in the 200 range for a successful request. For the
// RequestResponse invocation type, this status code is 200. For the Event
// invocation type, this status code is 202. For the DryRun invocation type, the
// status code is 204.
StatusCode int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationInvokeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpInvoke{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpInvoke{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpInvokeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opInvoke(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opInvoke(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "Invoke",
}
}
| 207 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
)
// For asynchronous function invocation, use Invoke . Invokes a function
// asynchronously.
//
// Deprecated: This operation has been deprecated.
func (c *Client) InvokeAsync(ctx context.Context, params *InvokeAsyncInput, optFns ...func(*Options)) (*InvokeAsyncOutput, error) {
if params == nil {
params = &InvokeAsyncInput{}
}
result, metadata, err := c.invokeOperation(ctx, "InvokeAsync", params, optFns, c.addOperationInvokeAsyncMiddlewares)
if err != nil {
return nil, err
}
out := result.(*InvokeAsyncOutput)
out.ResultMetadata = metadata
return out, nil
}
type InvokeAsyncInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// The JSON that you want to provide to your Lambda function as input.
//
// This member is required.
InvokeArgs io.Reader
noSmithyDocumentSerde
}
// A success response ( 202 Accepted ) indicates that the request is queued for
// invocation.
type InvokeAsyncOutput struct {
// The status code.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationInvokeAsyncMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpInvokeAsync{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpInvokeAsync{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpInvokeAsyncValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opInvokeAsync(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opInvokeAsync(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "InvokeAsync",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithysync "github.com/aws/smithy-go/sync"
smithyhttp "github.com/aws/smithy-go/transport/http"
"sync"
)
// Configure your Lambda functions to stream response payloads back to clients.
// For more information, see Configuring a Lambda function to stream responses (https://docs.aws.amazon.com/lambda/latest/dg/configuration-response-streaming.html)
// . This operation requires permission for the lambda:InvokeFunction (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awslambda.html)
// action. For details on how to set up permissions for cross-account invocations,
// see Granting function access to other accounts (https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html#permissions-resource-xaccountinvoke)
// .
func (c *Client) InvokeWithResponseStream(ctx context.Context, params *InvokeWithResponseStreamInput, optFns ...func(*Options)) (*InvokeWithResponseStreamOutput, error) {
if params == nil {
params = &InvokeWithResponseStreamInput{}
}
result, metadata, err := c.invokeOperation(ctx, "InvokeWithResponseStream", params, optFns, c.addOperationInvokeWithResponseStreamMiddlewares)
if err != nil {
return nil, err
}
out := result.(*InvokeWithResponseStreamOutput)
out.ResultMetadata = metadata
return out, nil
}
type InvokeWithResponseStreamInput struct {
// The name of the Lambda function. Name formats
// - Function name – my-function .
// - Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function .
// - Partial ARN – 123456789012:function:my-function .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Up to 3,583 bytes of base64-encoded data about the invoking client to pass to
// the function in the context object.
ClientContext *string
// Use one of the following options:
// - RequestResponse (default) – Invoke the function synchronously. Keep the
// connection open until the function returns a response or times out. The API
// operation response includes the function response and additional data.
// - DryRun – Validate parameter values and verify that the IAM user or role has
// permission to invoke the function.
InvocationType types.ResponseStreamingInvocationType
// Set to Tail to include the execution log in the response. Applies to
// synchronously invoked functions only.
LogType types.LogType
// The JSON that you want to provide to your Lambda function as input. You can
// enter the JSON directly. For example, --payload '{ "key": "value" }' . You can
// also specify a file path. For example, --payload file://payload.json .
Payload []byte
// The alias name.
Qualifier *string
noSmithyDocumentSerde
}
type InvokeWithResponseStreamOutput struct {
// The version of the function that executed. When you invoke a function with an
// alias, this indicates which version the alias resolved to.
ExecutedVersion *string
// The type of data the stream is returning.
ResponseStreamContentType *string
// For a successful request, the HTTP status code is in the 200 range. For the
// RequestResponse invocation type, this status code is 200. For the DryRun
// invocation type, this status code is 204.
StatusCode int32
eventStream *InvokeWithResponseStreamEventStream
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
// GetStream returns the type to interact with the event stream.
func (o *InvokeWithResponseStreamOutput) GetStream() *InvokeWithResponseStreamEventStream {
return o.eventStream
}
func (c *Client) addOperationInvokeWithResponseStreamMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpInvokeWithResponseStream{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpInvokeWithResponseStream{}, middleware.After)
if err != nil {
return err
}
if err = addEventStreamInvokeWithResponseStreamMiddleware(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = addOpInvokeWithResponseStreamValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opInvokeWithResponseStream(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opInvokeWithResponseStream(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "InvokeWithResponseStream",
}
}
// InvokeWithResponseStreamEventStream provides the event stream handling for the InvokeWithResponseStream operation.
//
// For testing and mocking the event stream this type should be initialized via
// the NewInvokeWithResponseStreamEventStream constructor function. Using the functional options
// to pass in nested mock behavior.
type InvokeWithResponseStreamEventStream struct {
// InvokeWithResponseStreamResponseEventReader is the EventStream reader for the
// InvokeWithResponseStreamResponseEvent 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 InvokeWithResponseStreamResponseEventReader
done chan struct{}
closeOnce sync.Once
err *smithysync.OnceErr
}
// NewInvokeWithResponseStreamEventStream initializes an InvokeWithResponseStreamEventStream.
// This function should only be used for testing and mocking the InvokeWithResponseStreamEventStream
// stream within your application.
//
// The Reader member must be set before reading events from the stream.
func NewInvokeWithResponseStreamEventStream(optFns ...func(*InvokeWithResponseStreamEventStream)) *InvokeWithResponseStreamEventStream {
es := &InvokeWithResponseStreamEventStream{
done: make(chan struct{}),
err: smithysync.NewOnceErr(),
}
for _, fn := range optFns {
fn(es)
}
return es
}
// Events returns a channel to read events from.
func (es *InvokeWithResponseStreamEventStream) Events() <-chan types.InvokeWithResponseStreamResponseEvent {
return es.Reader.Events()
}
// 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.
//
// Will close the underlying EventStream writer and reader, and no more events can be
// sent or received.
func (es *InvokeWithResponseStreamEventStream) Close() error {
es.closeOnce.Do(es.safeClose)
return es.Err()
}
func (es *InvokeWithResponseStreamEventStream) safeClose() {
close(es.done)
es.Reader.Close()
}
// 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 *InvokeWithResponseStreamEventStream) Err() error {
if err := es.err.Err(); err != nil {
return err
}
if err := es.Reader.Err(); err != nil {
return err
}
return nil
}
func (es *InvokeWithResponseStreamEventStream) waitStreamClose() {
type errorSet interface {
ErrorSet() <-chan struct{}
}
var outputErrCh <-chan struct{}
if v, ok := es.Reader.(errorSet); ok {
outputErrCh = v.ErrorSet()
}
var outputClosedCh <-chan struct{}
if v, ok := es.Reader.(interface{ Closed() <-chan struct{} }); ok {
outputClosedCh = v.Closed()
}
select {
case <-es.done:
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()
}
}
| 274 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of aliases (https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html)
// for a Lambda function.
func (c *Client) ListAliases(ctx context.Context, params *ListAliasesInput, optFns ...func(*Options)) (*ListAliasesOutput, error) {
if params == nil {
params = &ListAliasesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAliases", params, optFns, c.addOperationListAliasesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAliasesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAliasesInput struct {
// The name of the Lambda function. Name formats
// - Function name - MyFunction .
// - Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction .
// - Partial ARN - 123456789012:function:MyFunction .
// The length constraint applies only to the full ARN. If you specify only the
// function name, it is limited to 64 characters in length.
//
// This member is required.
FunctionName *string
// Specify a function version to only list aliases that invoke that version.
FunctionVersion *string
// Specify the pagination token that's returned by a previous request to retrieve
// the next page of results.
Marker *string
// Limit the number of aliases returned.
MaxItems *int32
noSmithyDocumentSerde
}
type ListAliasesOutput struct {
// A list of aliases.
Aliases []types.AliasConfiguration
// The pagination token that's included if more results are available.
NextMarker *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAliasesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAliases{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAliases{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListAliasesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAliases(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListAliasesAPIClient is a client that implements the ListAliases operation.
type ListAliasesAPIClient interface {
ListAliases(context.Context, *ListAliasesInput, ...func(*Options)) (*ListAliasesOutput, error)
}
var _ ListAliasesAPIClient = (*Client)(nil)
// ListAliasesPaginatorOptions is the paginator options for ListAliases
type ListAliasesPaginatorOptions struct {
// Limit the number of aliases returned.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListAliasesPaginator is a paginator for ListAliases
type ListAliasesPaginator struct {
options ListAliasesPaginatorOptions
client ListAliasesAPIClient
params *ListAliasesInput
nextToken *string
firstPage bool
}
// NewListAliasesPaginator returns a new ListAliasesPaginator
func NewListAliasesPaginator(client ListAliasesAPIClient, params *ListAliasesInput, optFns ...func(*ListAliasesPaginatorOptions)) *ListAliasesPaginator {
if params == nil {
params = &ListAliasesInput{}
}
options := ListAliasesPaginatorOptions{}
if params.MaxItems != nil {
options.Limit = *params.MaxItems
}
for _, fn := range optFns {
fn(&options)
}
return &ListAliasesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.Marker,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAliasesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAliases page.
func (p *ListAliasesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAliasesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.Marker = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxItems = limit
result, err := p.client.ListAliases(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextMarker
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListAliases(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "ListAliases",
}
}
| 234 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package lambda
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of code signing configurations (https://docs.aws.amazon.com/lambda/latest/dg/configuring-codesigning.html)
// . A request returns up to 10,000 configurations per call. You can use the
// MaxItems parameter to return fewer configurations per call.
func (c *Client) ListCodeSigningConfigs(ctx context.Context, params *ListCodeSigningConfigsInput, optFns ...func(*Options)) (*ListCodeSigningConfigsOutput, error) {
if params == nil {
params = &ListCodeSigningConfigsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListCodeSigningConfigs", params, optFns, c.addOperationListCodeSigningConfigsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListCodeSigningConfigsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListCodeSigningConfigsInput struct {
// Specify the pagination token that's returned by a previous request to retrieve
// the next page of results.
Marker *string
// Maximum number of items to return.
MaxItems *int32
noSmithyDocumentSerde
}
type ListCodeSigningConfigsOutput struct {
// The code signing configurations
CodeSigningConfigs []types.CodeSigningConfig
// The pagination token that's included if more results are available.
NextMarker *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListCodeSigningConfigsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListCodeSigningConfigs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListCodeSigningConfigs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListCodeSigningConfigs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListCodeSigningConfigsAPIClient is a client that implements the
// ListCodeSigningConfigs operation.
type ListCodeSigningConfigsAPIClient interface {
ListCodeSigningConfigs(context.Context, *ListCodeSigningConfigsInput, ...func(*Options)) (*ListCodeSigningConfigsOutput, error)
}
var _ ListCodeSigningConfigsAPIClient = (*Client)(nil)
// ListCodeSigningConfigsPaginatorOptions is the paginator options for
// ListCodeSigningConfigs
type ListCodeSigningConfigsPaginatorOptions struct {
// Maximum number of items to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListCodeSigningConfigsPaginator is a paginator for ListCodeSigningConfigs
type ListCodeSigningConfigsPaginator struct {
options ListCodeSigningConfigsPaginatorOptions
client ListCodeSigningConfigsAPIClient
params *ListCodeSigningConfigsInput
nextToken *string
firstPage bool
}
// NewListCodeSigningConfigsPaginator returns a new ListCodeSigningConfigsPaginator
func NewListCodeSigningConfigsPaginator(client ListCodeSigningConfigsAPIClient, params *ListCodeSigningConfigsInput, optFns ...func(*ListCodeSigningConfigsPaginatorOptions)) *ListCodeSigningConfigsPaginator {
if params == nil {
params = &ListCodeSigningConfigsInput{}
}
options := ListCodeSigningConfigsPaginatorOptions{}
if params.MaxItems != nil {
options.Limit = *params.MaxItems
}
for _, fn := range optFns {
fn(&options)
}
return &ListCodeSigningConfigsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.Marker,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListCodeSigningConfigsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListCodeSigningConfigs page.
func (p *ListCodeSigningConfigsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCodeSigningConfigsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.Marker = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxItems = limit
result, err := p.client.ListCodeSigningConfigs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextMarker
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListCodeSigningConfigs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "lambda",
OperationName: "ListCodeSigningConfigs",
}
}
| 221 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.