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
|
|---|---|---|---|---|
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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"
)
func (c *Client) ListAccessKeys(ctx context.Context, params *ListAccessKeysInput, optFns ...func(*Options)) (*ListAccessKeysOutput, error) {
if params == nil {
params = &ListAccessKeysInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAccessKeys", params, optFns, c.addOperationListAccessKeysMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAccessKeysOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAccessKeysInput struct {
NextToken *string
noSmithyDocumentSerde
}
type ListAccessKeysOutput struct {
AccessKeyIds []string
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAccessKeysMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListAccessKeys{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListAccessKeys{}, 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_opListAccessKeys(options.Region), middleware.Before); 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_opListAccessKeys(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "ListAccessKeys",
}
}
| 113 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func (c *Client) ListCertificates(ctx context.Context, params *ListCertificatesInput, optFns ...func(*Options)) (*ListCertificatesOutput, error) {
if params == nil {
params = &ListCertificatesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListCertificates", params, optFns, c.addOperationListCertificatesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListCertificatesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListCertificatesInput struct {
NextToken *string
noSmithyDocumentSerde
}
type ListCertificatesOutput struct {
// This member is required.
Certificates []types.CertificateSummary
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListCertificatesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListCertificates{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListCertificates{}, 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_opListCertificates(options.Region), middleware.Before); 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_opListCertificates(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "ListCertificates",
}
}
| 116 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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"
)
func (c *Client) ListServices(ctx context.Context, params *ListServicesInput, optFns ...func(*Options)) (*ListServicesOutput, error) {
if params == nil {
params = &ListServicesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListServices", params, optFns, c.addOperationListServicesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListServicesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListServicesInput struct {
NextToken *string
noSmithyDocumentSerde
}
type ListServicesOutput struct {
NextToken *string
ServiceIds []string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListServicesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListServices{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListServices{}, 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_opListServices(options.Region), middleware.Before); 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_opListServices(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "ListServices",
}
}
| 113 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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"
)
func (c *Client) PutNotificationConfiguration(ctx context.Context, params *PutNotificationConfigurationInput, optFns ...func(*Options)) (*PutNotificationConfigurationOutput, error) {
if params == nil {
params = &PutNotificationConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutNotificationConfiguration", params, optFns, c.addOperationPutNotificationConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutNotificationConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutNotificationConfigurationInput struct {
// This member is required.
Enabled *bool
// This member is required.
ServiceId *string
BrokerEndpoint *string
CaCertificate *string
noSmithyDocumentSerde
}
type PutNotificationConfigurationOutput struct {
Message *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutNotificationConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutNotificationConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutNotificationConfiguration{}, 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 = addOpPutNotificationConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutNotificationConfiguration(options.Region), middleware.Before); 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_opPutNotificationConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "PutNotificationConfiguration",
}
}
| 123 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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"
)
func (c *Client) RebootDevice(ctx context.Context, params *RebootDeviceInput, optFns ...func(*Options)) (*RebootDeviceOutput, error) {
if params == nil {
params = &RebootDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RebootDevice", params, optFns, c.addOperationRebootDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RebootDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type RebootDeviceInput struct {
noSmithyDocumentSerde
}
type RebootDeviceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRebootDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpRebootDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpRebootDevice{}, 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_opRebootDevice(options.Region), middleware.Before); 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_opRebootDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "RebootDevice",
}
}
| 107 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func (c *Client) SetFeatures(ctx context.Context, params *SetFeaturesInput, optFns ...func(*Options)) (*SetFeaturesOutput, error) {
if params == nil {
params = &SetFeaturesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SetFeatures", params, optFns, c.addOperationSetFeaturesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SetFeaturesOutput)
out.ResultMetadata = metadata
return out, nil
}
type SetFeaturesInput struct {
// This member is required.
RemoteManagementState types.RemoteManagementState
noSmithyDocumentSerde
}
type SetFeaturesOutput struct {
RemoteManagementState types.RemoteManagementState
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSetFeaturesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpSetFeatures{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpSetFeatures{}, 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 = addOpSetFeaturesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSetFeatures(options.Region), middleware.Before); 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_opSetFeatures(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "SetFeatures",
}
}
| 117 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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"
)
func (c *Client) ShutdownDevice(ctx context.Context, params *ShutdownDeviceInput, optFns ...func(*Options)) (*ShutdownDeviceOutput, error) {
if params == nil {
params = &ShutdownDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ShutdownDevice", params, optFns, c.addOperationShutdownDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ShutdownDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type ShutdownDeviceInput struct {
noSmithyDocumentSerde
}
type ShutdownDeviceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationShutdownDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpShutdownDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpShutdownDevice{}, 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_opShutdownDevice(options.Region), middleware.Before); 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_opShutdownDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "ShutdownDevice",
}
}
| 107 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func (c *Client) StartService(ctx context.Context, params *StartServiceInput, optFns ...func(*Options)) (*StartServiceOutput, error) {
if params == nil {
params = &StartServiceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartService", params, optFns, c.addOperationStartServiceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartServiceOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartServiceInput struct {
ServiceConfiguration *types.ServiceConfiguration
ServiceId *string
VirtualNetworkInterfaceArns []string
noSmithyDocumentSerde
}
type StartServiceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartServiceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStartService{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStartService{}, 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_opStartService(options.Region), middleware.Before); 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_opStartService(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "StartService",
}
}
| 114 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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"
)
func (c *Client) StopService(ctx context.Context, params *StopServiceInput, optFns ...func(*Options)) (*StopServiceOutput, error) {
if params == nil {
params = &StopServiceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StopService", params, optFns, c.addOperationStopServiceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StopServiceOutput)
out.ResultMetadata = metadata
return out, nil
}
type StopServiceInput struct {
ServiceId *string
Terminate bool
noSmithyDocumentSerde
}
type StopServiceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStopServiceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpStopService{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpStopService{}, 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_opStopService(options.Region), middleware.Before); 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_opStopService(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "StopService",
}
}
| 111 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func (c *Client) UpdateAutoStartConfiguration(ctx context.Context, params *UpdateAutoStartConfigurationInput, optFns ...func(*Options)) (*UpdateAutoStartConfigurationOutput, error) {
if params == nil {
params = &UpdateAutoStartConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateAutoStartConfiguration", params, optFns, c.addOperationUpdateAutoStartConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateAutoStartConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateAutoStartConfigurationInput struct {
// This member is required.
AutoStartConfigurationArn *string
Enabled *bool
IpAddressAssignment types.IpAddressAssignment
LaunchTemplateId *string
LaunchTemplateVersion *string
PhysicalConnectorType types.PhysicalConnectorType
StaticIpAddressConfiguration *types.StaticIpAddressConfiguration
noSmithyDocumentSerde
}
type UpdateAutoStartConfigurationOutput struct {
AutoStartConfiguration *types.AutoStartConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateAutoStartConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateAutoStartConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateAutoStartConfiguration{}, 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 = addOpUpdateAutoStartConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateAutoStartConfiguration(options.Region), middleware.Before); 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_opUpdateAutoStartConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "UpdateAutoStartConfiguration",
}
}
| 129 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func (c *Client) UpdateDirectNetworkInterface(ctx context.Context, params *UpdateDirectNetworkInterfaceInput, optFns ...func(*Options)) (*UpdateDirectNetworkInterfaceOutput, error) {
if params == nil {
params = &UpdateDirectNetworkInterfaceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateDirectNetworkInterface", params, optFns, c.addOperationUpdateDirectNetworkInterfaceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateDirectNetworkInterfaceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateDirectNetworkInterfaceInput struct {
// This member is required.
DirectNetworkInterfaceArn *string
Detach bool
InstanceId *string
MacAddress *string
VlanId *int32
noSmithyDocumentSerde
}
type UpdateDirectNetworkInterfaceOutput struct {
// This member is required.
DirectNetworkInterface *types.DirectNetworkInterface
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateDirectNetworkInterfaceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateDirectNetworkInterface{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateDirectNetworkInterface{}, 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 = addOpUpdateDirectNetworkInterfaceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateDirectNetworkInterface(options.Region), middleware.Before); 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_opUpdateDirectNetworkInterface(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "UpdateDirectNetworkInterface",
}
}
| 127 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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"
)
func (c *Client) UpdateTimeServers(ctx context.Context, params *UpdateTimeServersInput, optFns ...func(*Options)) (*UpdateTimeServersOutput, error) {
if params == nil {
params = &UpdateTimeServersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateTimeServers", params, optFns, c.addOperationUpdateTimeServersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateTimeServersOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateTimeServersInput struct {
Servers []string
noSmithyDocumentSerde
}
type UpdateTimeServersOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateTimeServersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateTimeServers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateTimeServers{}, 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_opUpdateTimeServers(options.Region), middleware.Before); 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_opUpdateTimeServers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "UpdateTimeServers",
}
}
| 109 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func (c *Client) UpdateVirtualNetworkInterface(ctx context.Context, params *UpdateVirtualNetworkInterfaceInput, optFns ...func(*Options)) (*UpdateVirtualNetworkInterfaceOutput, error) {
if params == nil {
params = &UpdateVirtualNetworkInterfaceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateVirtualNetworkInterface", params, optFns, c.addOperationUpdateVirtualNetworkInterfaceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateVirtualNetworkInterfaceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateVirtualNetworkInterfaceInput struct {
// This member is required.
IpAddressAssignment types.IpAddressAssignment
// This member is required.
VirtualNetworkInterfaceArn *string
StaticIpAddressConfiguration *types.StaticIpAddressConfiguration
noSmithyDocumentSerde
}
type UpdateVirtualNetworkInterfaceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateVirtualNetworkInterfaceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateVirtualNetworkInterface{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateVirtualNetworkInterface{}, 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 = addOpUpdateVirtualNetworkInterfaceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateVirtualNetworkInterface(options.Region), middleware.Before); 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_opUpdateVirtualNetworkInterface(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "snowballdevice",
OperationName: "UpdateVirtualNetworkInterface",
}
}
| 120 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/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"
"io/ioutil"
"strings"
)
type awsAwsjson11_deserializeOpCheckForUpdates struct {
}
func (*awsAwsjson11_deserializeOpCheckForUpdates) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCheckForUpdates) 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, awsAwsjson11_deserializeOpErrorCheckForUpdates(response, &metadata)
}
output := &CheckForUpdatesOutput{}
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 = awsAwsjson11_deserializeOpDocumentCheckForUpdatesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCheckForUpdates(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("NoCloudConnectionException", errorCode):
return awsAwsjson11_deserializeErrorNoCloudConnectionException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpConfigureAutoUpdateStrategy struct {
}
func (*awsAwsjson11_deserializeOpConfigureAutoUpdateStrategy) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpConfigureAutoUpdateStrategy) 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, awsAwsjson11_deserializeOpErrorConfigureAutoUpdateStrategy(response, &metadata)
}
output := &ConfigureAutoUpdateStrategyOutput{}
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 = awsAwsjson11_deserializeOpDocumentConfigureAutoUpdateStrategyOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorConfigureAutoUpdateStrategy(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateAutoStartConfiguration struct {
}
func (*awsAwsjson11_deserializeOpCreateAutoStartConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateAutoStartConfiguration) 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, awsAwsjson11_deserializeOpErrorCreateAutoStartConfiguration(response, &metadata)
}
output := &CreateAutoStartConfigurationOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateAutoStartConfigurationOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateAutoStartConfiguration(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateDirectNetworkInterface struct {
}
func (*awsAwsjson11_deserializeOpCreateDirectNetworkInterface) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateDirectNetworkInterface) 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, awsAwsjson11_deserializeOpErrorCreateDirectNetworkInterface(response, &metadata)
}
output := &CreateDirectNetworkInterfaceOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateDirectNetworkInterfaceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateDirectNetworkInterface(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MaxDirectNetworkExceededException", errorCode):
return awsAwsjson11_deserializeErrorMaxDirectNetworkExceededException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("NoDirectNetworkSupportException", errorCode):
return awsAwsjson11_deserializeErrorNoDirectNetworkSupportException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsAwsjson11_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateTags struct {
}
func (*awsAwsjson11_deserializeOpCreateTags) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateTags) 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, awsAwsjson11_deserializeOpErrorCreateTags(response, &metadata)
}
output := &CreateTagsOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateTagsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateTags(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateVirtualNetworkInterface struct {
}
func (*awsAwsjson11_deserializeOpCreateVirtualNetworkInterface) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateVirtualNetworkInterface) 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, awsAwsjson11_deserializeOpErrorCreateVirtualNetworkInterface(response, &metadata)
}
output := &CreateVirtualNetworkInterfaceOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateVirtualNetworkInterfaceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateVirtualNetworkInterface(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteAutoStartConfiguration struct {
}
func (*awsAwsjson11_deserializeOpDeleteAutoStartConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteAutoStartConfiguration) 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, awsAwsjson11_deserializeOpErrorDeleteAutoStartConfiguration(response, &metadata)
}
output := &DeleteAutoStartConfigurationOutput{}
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 = awsAwsjson11_deserializeOpDocumentDeleteAutoStartConfigurationOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteAutoStartConfiguration(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteDirectNetworkInterface struct {
}
func (*awsAwsjson11_deserializeOpDeleteDirectNetworkInterface) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteDirectNetworkInterface) 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, awsAwsjson11_deserializeOpErrorDeleteDirectNetworkInterface(response, &metadata)
}
output := &DeleteDirectNetworkInterfaceOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteDirectNetworkInterface(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsAwsjson11_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteTags struct {
}
func (*awsAwsjson11_deserializeOpDeleteTags) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteTags) 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, awsAwsjson11_deserializeOpErrorDeleteTags(response, &metadata)
}
output := &DeleteTagsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDeleteTagsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteTags(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteVirtualNetworkInterface struct {
}
func (*awsAwsjson11_deserializeOpDeleteVirtualNetworkInterface) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteVirtualNetworkInterface) 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, awsAwsjson11_deserializeOpErrorDeleteVirtualNetworkInterface(response, &metadata)
}
output := &DeleteVirtualNetworkInterfaceOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteVirtualNetworkInterface(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeAutoStartConfigurations struct {
}
func (*awsAwsjson11_deserializeOpDescribeAutoStartConfigurations) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeAutoStartConfigurations) 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, awsAwsjson11_deserializeOpErrorDescribeAutoStartConfigurations(response, &metadata)
}
output := &DescribeAutoStartConfigurationsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeAutoStartConfigurationsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeAutoStartConfigurations(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeAutoUpdateStrategies struct {
}
func (*awsAwsjson11_deserializeOpDescribeAutoUpdateStrategies) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeAutoUpdateStrategies) 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, awsAwsjson11_deserializeOpErrorDescribeAutoUpdateStrategies(response, &metadata)
}
output := &DescribeAutoUpdateStrategiesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeAutoUpdateStrategiesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeAutoUpdateStrategies(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeCluster struct {
}
func (*awsAwsjson11_deserializeOpDescribeCluster) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeCluster) 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, awsAwsjson11_deserializeOpErrorDescribeCluster(response, &metadata)
}
output := &DescribeClusterOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeClusterOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeCluster(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidPaginationTokenException", errorCode):
return awsAwsjson11_deserializeErrorInvalidPaginationTokenException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsAwsjson11_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeDevice struct {
}
func (*awsAwsjson11_deserializeOpDescribeDevice) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeDevice) 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, awsAwsjson11_deserializeOpErrorDescribeDevice(response, &metadata)
}
output := &DescribeDeviceOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeDeviceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeDevice(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeDeviceSoftware struct {
}
func (*awsAwsjson11_deserializeOpDescribeDeviceSoftware) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeDeviceSoftware) 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, awsAwsjson11_deserializeOpErrorDescribeDeviceSoftware(response, &metadata)
}
output := &DescribeDeviceSoftwareOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeDeviceSoftwareOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeDeviceSoftware(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeDirectNetworkInterfaces struct {
}
func (*awsAwsjson11_deserializeOpDescribeDirectNetworkInterfaces) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeDirectNetworkInterfaces) 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, awsAwsjson11_deserializeOpErrorDescribeDirectNetworkInterfaces(response, &metadata)
}
output := &DescribeDirectNetworkInterfacesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeDirectNetworkInterfacesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeDirectNetworkInterfaces(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidPaginationTokenException", errorCode):
return awsAwsjson11_deserializeErrorInvalidPaginationTokenException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeFeatures struct {
}
func (*awsAwsjson11_deserializeOpDescribeFeatures) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeFeatures) 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, awsAwsjson11_deserializeOpErrorDescribeFeatures(response, &metadata)
}
output := &DescribeFeaturesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeFeaturesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeFeatures(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribePhysicalNetworkInterfaces struct {
}
func (*awsAwsjson11_deserializeOpDescribePhysicalNetworkInterfaces) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribePhysicalNetworkInterfaces) 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, awsAwsjson11_deserializeOpErrorDescribePhysicalNetworkInterfaces(response, &metadata)
}
output := &DescribePhysicalNetworkInterfacesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribePhysicalNetworkInterfacesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribePhysicalNetworkInterfaces(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidPaginationTokenException", errorCode):
return awsAwsjson11_deserializeErrorInvalidPaginationTokenException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeReturnShippingLabel struct {
}
func (*awsAwsjson11_deserializeOpDescribeReturnShippingLabel) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeReturnShippingLabel) 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, awsAwsjson11_deserializeOpErrorDescribeReturnShippingLabel(response, &metadata)
}
output := &DescribeReturnShippingLabelOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeReturnShippingLabelOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeReturnShippingLabel(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsAwsjson11_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeService struct {
}
func (*awsAwsjson11_deserializeOpDescribeService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeService) 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, awsAwsjson11_deserializeOpErrorDescribeService(response, &metadata)
}
output := &DescribeServiceOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeServiceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeService(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeTags struct {
}
func (*awsAwsjson11_deserializeOpDescribeTags) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeTags) 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, awsAwsjson11_deserializeOpErrorDescribeTags(response, &metadata)
}
output := &DescribeTagsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeTagsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeTags(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeTimeSources struct {
}
func (*awsAwsjson11_deserializeOpDescribeTimeSources) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeTimeSources) 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, awsAwsjson11_deserializeOpErrorDescribeTimeSources(response, &metadata)
}
output := &DescribeTimeSourcesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeTimeSourcesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeTimeSources(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("TimeServiceUnavailableException", errorCode):
return awsAwsjson11_deserializeErrorTimeServiceUnavailableException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeVirtualNetworkInterfaces struct {
}
func (*awsAwsjson11_deserializeOpDescribeVirtualNetworkInterfaces) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeVirtualNetworkInterfaces) 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, awsAwsjson11_deserializeOpErrorDescribeVirtualNetworkInterfaces(response, &metadata)
}
output := &DescribeVirtualNetworkInterfacesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeVirtualNetworkInterfacesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeVirtualNetworkInterfaces(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidPaginationTokenException", errorCode):
return awsAwsjson11_deserializeErrorInvalidPaginationTokenException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDownloadUpdates struct {
}
func (*awsAwsjson11_deserializeOpDownloadUpdates) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDownloadUpdates) 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, awsAwsjson11_deserializeOpErrorDownloadUpdates(response, &metadata)
}
output := &DownloadUpdatesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDownloadUpdatesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDownloadUpdates(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("IncorrectDeviceUpdateStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceUpdateStateException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetCertificate struct {
}
func (*awsAwsjson11_deserializeOpGetCertificate) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetCertificate) 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, awsAwsjson11_deserializeOpErrorGetCertificate(response, &metadata)
}
output := &GetCertificateOutput{}
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 = awsAwsjson11_deserializeOpDocumentGetCertificateOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetCertificate(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetNotificationConfiguration struct {
}
func (*awsAwsjson11_deserializeOpGetNotificationConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetNotificationConfiguration) 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, awsAwsjson11_deserializeOpErrorGetNotificationConfiguration(response, &metadata)
}
output := &GetNotificationConfigurationOutput{}
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 = awsAwsjson11_deserializeOpDocumentGetNotificationConfigurationOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetNotificationConfiguration(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetReturnShippingLabel struct {
}
func (*awsAwsjson11_deserializeOpGetReturnShippingLabel) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetReturnShippingLabel) 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, awsAwsjson11_deserializeOpErrorGetReturnShippingLabel(response, &metadata)
}
output := &GetReturnShippingLabelOutput{}
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 = awsAwsjson11_deserializeOpDocumentGetReturnShippingLabelOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetReturnShippingLabel(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("NoCloudConnectionException", errorCode):
return awsAwsjson11_deserializeErrorNoCloudConnectionException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsAwsjson11_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetSecretAccessKey struct {
}
func (*awsAwsjson11_deserializeOpGetSecretAccessKey) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetSecretAccessKey) 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, awsAwsjson11_deserializeOpErrorGetSecretAccessKey(response, &metadata)
}
output := &GetSecretAccessKeyOutput{}
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 = awsAwsjson11_deserializeOpDocumentGetSecretAccessKeyOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetSecretAccessKey(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpInstallUpdates struct {
}
func (*awsAwsjson11_deserializeOpInstallUpdates) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpInstallUpdates) 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, awsAwsjson11_deserializeOpErrorInstallUpdates(response, &metadata)
}
output := &InstallUpdatesOutput{}
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 = awsAwsjson11_deserializeOpDocumentInstallUpdatesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorInstallUpdates(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("IncorrectDeviceUpdateStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceUpdateStateException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListAccessKeys struct {
}
func (*awsAwsjson11_deserializeOpListAccessKeys) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListAccessKeys) 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, awsAwsjson11_deserializeOpErrorListAccessKeys(response, &metadata)
}
output := &ListAccessKeysOutput{}
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 = awsAwsjson11_deserializeOpDocumentListAccessKeysOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListAccessKeys(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidPaginationTokenException", errorCode):
return awsAwsjson11_deserializeErrorInvalidPaginationTokenException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListCertificates struct {
}
func (*awsAwsjson11_deserializeOpListCertificates) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListCertificates) 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, awsAwsjson11_deserializeOpErrorListCertificates(response, &metadata)
}
output := &ListCertificatesOutput{}
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 = awsAwsjson11_deserializeOpDocumentListCertificatesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListCertificates(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidPaginationTokenException", errorCode):
return awsAwsjson11_deserializeErrorInvalidPaginationTokenException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListServices struct {
}
func (*awsAwsjson11_deserializeOpListServices) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListServices) 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, awsAwsjson11_deserializeOpErrorListServices(response, &metadata)
}
output := &ListServicesOutput{}
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 = awsAwsjson11_deserializeOpDocumentListServicesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListServices(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidPaginationTokenException", errorCode):
return awsAwsjson11_deserializeErrorInvalidPaginationTokenException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpPutNotificationConfiguration struct {
}
func (*awsAwsjson11_deserializeOpPutNotificationConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpPutNotificationConfiguration) 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, awsAwsjson11_deserializeOpErrorPutNotificationConfiguration(response, &metadata)
}
output := &PutNotificationConfigurationOutput{}
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 = awsAwsjson11_deserializeOpDocumentPutNotificationConfigurationOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorPutNotificationConfiguration(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpRebootDevice struct {
}
func (*awsAwsjson11_deserializeOpRebootDevice) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpRebootDevice) 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, awsAwsjson11_deserializeOpErrorRebootDevice(response, &metadata)
}
output := &RebootDeviceOutput{}
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 = awsAwsjson11_deserializeOpDocumentRebootDeviceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorRebootDevice(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpSetFeatures struct {
}
func (*awsAwsjson11_deserializeOpSetFeatures) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpSetFeatures) 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, awsAwsjson11_deserializeOpErrorSetFeatures(response, &metadata)
}
output := &SetFeaturesOutput{}
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 = awsAwsjson11_deserializeOpDocumentSetFeaturesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorSetFeatures(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("IncorrectRemoteManagementStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectRemoteManagementStateException(response, errorBody)
case strings.EqualFold("InternalFailureException", errorCode):
return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpShutdownDevice struct {
}
func (*awsAwsjson11_deserializeOpShutdownDevice) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpShutdownDevice) 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, awsAwsjson11_deserializeOpErrorShutdownDevice(response, &metadata)
}
output := &ShutdownDeviceOutput{}
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 = awsAwsjson11_deserializeOpDocumentShutdownDeviceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorShutdownDevice(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpStartService struct {
}
func (*awsAwsjson11_deserializeOpStartService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpStartService) 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, awsAwsjson11_deserializeOpErrorStartService(response, &metadata)
}
output := &StartServiceOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorStartService(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ServiceAlreadyStartedException", errorCode):
return awsAwsjson11_deserializeErrorServiceAlreadyStartedException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsAwsjson11_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpStopService struct {
}
func (*awsAwsjson11_deserializeOpStopService) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpStopService) 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, awsAwsjson11_deserializeOpErrorStopService(response, &metadata)
}
output := &StopServiceOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorStopService(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsAwsjson11_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateAutoStartConfiguration struct {
}
func (*awsAwsjson11_deserializeOpUpdateAutoStartConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateAutoStartConfiguration) 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, awsAwsjson11_deserializeOpErrorUpdateAutoStartConfiguration(response, &metadata)
}
output := &UpdateAutoStartConfigurationOutput{}
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 = awsAwsjson11_deserializeOpDocumentUpdateAutoStartConfigurationOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateAutoStartConfiguration(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateDirectNetworkInterface struct {
}
func (*awsAwsjson11_deserializeOpUpdateDirectNetworkInterface) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateDirectNetworkInterface) 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, awsAwsjson11_deserializeOpErrorUpdateDirectNetworkInterface(response, &metadata)
}
output := &UpdateDirectNetworkInterfaceOutput{}
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 = awsAwsjson11_deserializeOpDocumentUpdateDirectNetworkInterfaceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateDirectNetworkInterface(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MacAddressAlreadyInUseException", errorCode):
return awsAwsjson11_deserializeErrorMacAddressAlreadyInUseException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsAwsjson11_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateTimeServers struct {
}
func (*awsAwsjson11_deserializeOpUpdateTimeServers) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateTimeServers) 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, awsAwsjson11_deserializeOpErrorUpdateTimeServers(response, &metadata)
}
output := &UpdateTimeServersOutput{}
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 = awsAwsjson11_deserializeOpDocumentUpdateTimeServersOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateTimeServers(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("TimeServiceSettingPersistenceException", errorCode):
return awsAwsjson11_deserializeErrorTimeServiceSettingPersistenceException(response, errorBody)
case strings.EqualFold("TimeServiceUnavailableException", errorCode):
return awsAwsjson11_deserializeErrorTimeServiceUnavailableException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateVirtualNetworkInterface struct {
}
func (*awsAwsjson11_deserializeOpUpdateVirtualNetworkInterface) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateVirtualNetworkInterface) 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, awsAwsjson11_deserializeOpErrorUpdateVirtualNetworkInterface(response, &metadata)
}
output := &UpdateVirtualNetworkInterfaceOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateVirtualNetworkInterface(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
code := response.Header.Get("X-Amzn-ErrorType")
if len(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
code, 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(code) != 0 {
errorCode = restjson.SanitizeErrorCode(code)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("IncorrectDeviceStateException", errorCode):
return awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("MissingParameterException", errorCode):
return awsAwsjson11_deserializeErrorMissingParameterException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsAwsjson11_deserializeErrorIncorrectDeviceStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.IncorrectDeviceStateException{}
err := awsAwsjson11_deserializeDocumentIncorrectDeviceStateException(&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 awsAwsjson11_deserializeErrorIncorrectDeviceUpdateStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.IncorrectDeviceUpdateStateException{}
err := awsAwsjson11_deserializeDocumentIncorrectDeviceUpdateStateException(&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 awsAwsjson11_deserializeErrorIncorrectRemoteManagementStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.IncorrectRemoteManagementStateException{}
err := awsAwsjson11_deserializeDocumentIncorrectRemoteManagementStateException(&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 awsAwsjson11_deserializeErrorInternalFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InternalFailureException{}
err := awsAwsjson11_deserializeDocumentInternalFailureException(&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 awsAwsjson11_deserializeErrorInvalidPaginationTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidPaginationTokenException{}
err := awsAwsjson11_deserializeDocumentInvalidPaginationTokenException(&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 awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidParameterCombinationException{}
err := awsAwsjson11_deserializeDocumentInvalidParameterCombinationException(&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 awsAwsjson11_deserializeErrorInvalidParameterValueException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidParameterValueException{}
err := awsAwsjson11_deserializeDocumentInvalidParameterValueException(&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 awsAwsjson11_deserializeErrorMacAddressAlreadyInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.MacAddressAlreadyInUseException{}
err := awsAwsjson11_deserializeDocumentMacAddressAlreadyInUseException(&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 awsAwsjson11_deserializeErrorMaxDirectNetworkExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.MaxDirectNetworkExceededException{}
err := awsAwsjson11_deserializeDocumentMaxDirectNetworkExceededException(&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 awsAwsjson11_deserializeErrorMissingParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.MissingParameterException{}
err := awsAwsjson11_deserializeDocumentMissingParameterException(&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 awsAwsjson11_deserializeErrorNoCloudConnectionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.NoCloudConnectionException{}
err := awsAwsjson11_deserializeDocumentNoCloudConnectionException(&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 awsAwsjson11_deserializeErrorNoDirectNetworkSupportException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.NoDirectNetworkSupportException{}
err := awsAwsjson11_deserializeDocumentNoDirectNetworkSupportException(&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 awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ResourceNotFoundException{}
err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&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 awsAwsjson11_deserializeErrorServiceAlreadyStartedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ServiceAlreadyStartedException{}
err := awsAwsjson11_deserializeDocumentServiceAlreadyStartedException(&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 awsAwsjson11_deserializeErrorTimeServiceSettingPersistenceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.TimeServiceSettingPersistenceException{}
err := awsAwsjson11_deserializeDocumentTimeServiceSettingPersistenceException(&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 awsAwsjson11_deserializeErrorTimeServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.TimeServiceUnavailableException{}
err := awsAwsjson11_deserializeDocumentTimeServiceUnavailableException(&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 awsAwsjson11_deserializeErrorUnsupportedOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.UnsupportedOperationException{}
err := awsAwsjson11_deserializeDocumentUnsupportedOperationException(&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 awsAwsjson11_deserializeDocumentAccessKeyIdList(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 String to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAllowedHosts(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 CidrBlock to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAutoStartConfiguration(v **types.AutoStartConfiguration, 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.AutoStartConfiguration
if *v == nil {
sv = &types.AutoStartConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoStartConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
}
sv.AutoStartConfigurationArn = ptr.String(jtv)
}
case "Enabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Enabled = jtv
}
case "IpAddressAssignment":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IpAddressAssignment to be of type string, got %T instead", value)
}
sv.IpAddressAssignment = types.IpAddressAssignment(jtv)
}
case "LaunchTemplateId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.LaunchTemplateId = ptr.String(jtv)
}
case "LaunchTemplateVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.LaunchTemplateVersion = ptr.String(jtv)
}
case "PhysicalConnectorType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PhysicalConnectorType to be of type string, got %T instead", value)
}
sv.PhysicalConnectorType = types.PhysicalConnectorType(jtv)
}
case "StaticIpAddressConfiguration":
if err := awsAwsjson11_deserializeDocumentStaticIpAddressConfiguration(&sv.StaticIpAddressConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAutoStartConfigurationDetails(v **types.AutoStartConfigurationDetails, 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.AutoStartConfigurationDetails
if *v == nil {
sv = &types.AutoStartConfigurationDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoStartConfiguration":
if err := awsAwsjson11_deserializeDocumentAutoStartConfiguration(&sv.AutoStartConfiguration, value); err != nil {
return err
}
case "AutoStartDetails":
if err := awsAwsjson11_deserializeDocumentAutoStartDetails(&sv.AutoStartDetails, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAutoStartConfigurationDetailsList(v *[]types.AutoStartConfigurationDetails, 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.AutoStartConfigurationDetails
if *v == nil {
cv = []types.AutoStartConfigurationDetails{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AutoStartConfigurationDetails
destAddr := &col
if err := awsAwsjson11_deserializeDocumentAutoStartConfigurationDetails(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAutoStartDetails(v **types.AutoStartDetails, 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.AutoStartDetails
if *v == nil {
sv = &types.AutoStartDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "InstanceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.InstanceId = ptr.String(jtv)
}
case "InterfaceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.InterfaceId = ptr.String(jtv)
}
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.State = ptr.String(jtv)
}
case "StateMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.StateMessage = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAutoUpdateStrategy(v **types.AutoUpdateStrategy, 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.AutoUpdateStrategy
if *v == nil {
sv = &types.AutoUpdateStrategy{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoCheck":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.AutoCheck = jtv
}
case "AutoCheckFrequency":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CronExpression to be of type string, got %T instead", value)
}
sv.AutoCheckFrequency = ptr.String(jtv)
}
case "AutoDownload":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.AutoDownload = jtv
}
case "AutoDownloadFrequency":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CronExpression to be of type string, got %T instead", value)
}
sv.AutoDownloadFrequency = ptr.String(jtv)
}
case "AutoInstall":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.AutoInstall = jtv
}
case "AutoInstallFrequency":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CronExpression to be of type string, got %T instead", value)
}
sv.AutoInstallFrequency = ptr.String(jtv)
}
case "AutoReboot":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.AutoReboot = jtv
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAutoUpdateStrategyList(v *[]types.AutoUpdateStrategy, 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.AutoUpdateStrategy
if *v == nil {
cv = []types.AutoUpdateStrategy{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AutoUpdateStrategy
destAddr := &col
if err := awsAwsjson11_deserializeDocumentAutoUpdateStrategy(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentCapacity(v **types.Capacity, 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.Capacity
if *v == nil {
sv = &types.Capacity{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Available":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected GenericLong to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Available = ptr.Int64(i64)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Total":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected GenericLong to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Total = ptr.Int64(i64)
}
case "Unit":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Unit = ptr.String(jtv)
}
case "Used":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected GenericLong to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Used = ptr.Int64(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentCapacityList(v *[]types.Capacity, 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.Capacity
if *v == nil {
cv = []types.Capacity{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Capacity
destAddr := &col
if err := awsAwsjson11_deserializeDocumentCapacity(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentCertificateAssociation(v **types.CertificateAssociation, 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.CertificateAssociation
if *v == nil {
sv = &types.CertificateAssociation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CertificateArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
}
sv.CertificateArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentCertificateSummary(v **types.CertificateSummary, 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.CertificateSummary
if *v == nil {
sv = &types.CertificateSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CertificateArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
}
sv.CertificateArn = ptr.String(jtv)
}
case "SubjectAlternativeNames":
if err := awsAwsjson11_deserializeDocumentStringList(&sv.SubjectAlternativeNames, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentCertificateSummaryList(v *[]types.CertificateSummary, 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.CertificateSummary
if *v == nil {
cv = []types.CertificateSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CertificateSummary
destAddr := &col
if err := awsAwsjson11_deserializeDocumentCertificateSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentClusterAssociation(v **types.ClusterAssociation, 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.ClusterAssociation
if *v == nil {
sv = &types.ClusterAssociation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ClusteredNetworkInterface":
if err := awsAwsjson11_deserializeDocumentPhysicalNetworkInterface(&sv.ClusteredNetworkInterface, value); err != nil {
return err
}
case "ClusterId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ClusterId = ptr.String(jtv)
}
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ClusterAssociationState to be of type string, got %T instead", value)
}
sv.State = types.ClusterAssociationState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentDevice(v **types.Device, 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.Device
if *v == nil {
sv = &types.Device{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ActiveNetworkInterface":
if err := awsAwsjson11_deserializeDocumentNetworkInterface(&sv.ActiveNetworkInterface, value); err != nil {
return err
}
case "ClusterAssociation":
if err := awsAwsjson11_deserializeDocumentClusterAssociation(&sv.ClusterAssociation, value); err != nil {
return err
}
case "DeviceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DeviceId = ptr.String(jtv)
}
case "NetworkReachability":
if err := awsAwsjson11_deserializeDocumentNetworkReachability(&sv.NetworkReachability, value); err != nil {
return err
}
case "PhysicalNetworkInterfaces":
if err := awsAwsjson11_deserializeDocumentPhysicalNetworkInterfaceList(&sv.PhysicalNetworkInterfaces, value); err != nil {
return err
}
case "Tags":
if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
return err
}
case "UnlockStatus":
if err := awsAwsjson11_deserializeDocumentUnlockStatus(&sv.UnlockStatus, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentDeviceList(v *[]types.Device, 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.Device
if *v == nil {
cv = []types.Device{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Device
destAddr := &col
if err := awsAwsjson11_deserializeDocumentDevice(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentDirectNetworkInterface(v **types.DirectNetworkInterface, 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.DirectNetworkInterface
if *v == nil {
sv = &types.DirectNetworkInterface{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DirectNetworkInterfaceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
}
sv.DirectNetworkInterfaceArn = ptr.String(jtv)
}
case "Driver":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DirectNetworkDriver to be of type string, got %T instead", value)
}
sv.Driver = types.DirectNetworkDriver(jtv)
}
case "InstanceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.InstanceId = ptr.String(jtv)
}
case "MacAddress":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MacAddress to be of type string, got %T instead", value)
}
sv.MacAddress = ptr.String(jtv)
}
case "PhysicalNetworkInterfaceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.PhysicalNetworkInterfaceId = ptr.String(jtv)
}
case "VlanId":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected VlanId to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.VlanId = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentDirectNetworkInterfaceList(v *[]types.DirectNetworkInterface, 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.DirectNetworkInterface
if *v == nil {
cv = []types.DirectNetworkInterface{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DirectNetworkInterface
destAddr := &col
if err := awsAwsjson11_deserializeDocumentDirectNetworkInterface(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentEndpoint(v **types.Endpoint, 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.Endpoint
if *v == nil {
sv = &types.Endpoint{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CertificateAssociation":
if err := awsAwsjson11_deserializeDocumentCertificateAssociation(&sv.CertificateAssociation, value); err != nil {
return err
}
case "Host":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Host = ptr.String(jtv)
}
case "Port":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Port = int32(i64)
}
case "Protocol":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Protocol = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEndpointList(v *[]types.Endpoint, 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.Endpoint
if *v == nil {
cv = []types.Endpoint{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Endpoint
destAddr := &col
if err := awsAwsjson11_deserializeDocumentEndpoint(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentIncorrectDeviceStateException(v **types.IncorrectDeviceStateException, 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.IncorrectDeviceStateException
if *v == nil {
sv = &types.IncorrectDeviceStateException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentIncorrectDeviceUpdateStateException(v **types.IncorrectDeviceUpdateStateException, 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.IncorrectDeviceUpdateStateException
if *v == nil {
sv = &types.IncorrectDeviceUpdateStateException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentIncorrectRemoteManagementStateException(v **types.IncorrectRemoteManagementStateException, 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.IncorrectRemoteManagementStateException
if *v == nil {
sv = &types.IncorrectRemoteManagementStateException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInternalFailureException(v **types.InternalFailureException, 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.InternalFailureException
if *v == nil {
sv = &types.InternalFailureException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidPaginationTokenException(v **types.InvalidPaginationTokenException, 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.InvalidPaginationTokenException
if *v == nil {
sv = &types.InvalidPaginationTokenException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidParameterCombinationException(v **types.InvalidParameterCombinationException, 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.InvalidParameterCombinationException
if *v == nil {
sv = &types.InvalidParameterCombinationException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidParameterValueException(v **types.InvalidParameterValueException, 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.InvalidParameterValueException
if *v == nil {
sv = &types.InvalidParameterValueException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentMacAddressAlreadyInUseException(v **types.MacAddressAlreadyInUseException, 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.MacAddressAlreadyInUseException
if *v == nil {
sv = &types.MacAddressAlreadyInUseException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentMaxDirectNetworkExceededException(v **types.MaxDirectNetworkExceededException, 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.MaxDirectNetworkExceededException
if *v == nil {
sv = &types.MaxDirectNetworkExceededException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentMissingParameterException(v **types.MissingParameterException, 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.MissingParameterException
if *v == nil {
sv = &types.MissingParameterException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkInterface(v **types.NetworkInterface, 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.NetworkInterface
if *v == nil {
sv = &types.NetworkInterface{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "IpAddress":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.IpAddress = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkReachability(v **types.NetworkReachability, 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.NetworkReachability
if *v == nil {
sv = &types.NetworkReachability{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NetworkReachabilityState to be of type string, got %T instead", value)
}
sv.State = types.NetworkReachabilityState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNoCloudConnectionException(v **types.NoCloudConnectionException, 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.NoCloudConnectionException
if *v == nil {
sv = &types.NoCloudConnectionException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNoDirectNetworkSupportException(v **types.NoDirectNetworkSupportException, 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.NoDirectNetworkSupportException
if *v == nil {
sv = &types.NoDirectNetworkSupportException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPhysicalNetworkInterface(v **types.PhysicalNetworkInterface, 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.PhysicalNetworkInterface
if *v == nil {
sv = &types.PhysicalNetworkInterface{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DefaultGateway":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.DefaultGateway = ptr.String(jtv)
}
case "IpAddress":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.IpAddress = ptr.String(jtv)
}
case "IpAddressAssignment":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IpAddressAssignment to be of type string, got %T instead", value)
}
sv.IpAddressAssignment = types.IpAddressAssignment(jtv)
}
case "MacAddress":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.MacAddress = ptr.String(jtv)
}
case "Netmask":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.Netmask = ptr.String(jtv)
}
case "PhysicalConnectorType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PhysicalConnectorType to be of type string, got %T instead", value)
}
sv.PhysicalConnectorType = types.PhysicalConnectorType(jtv)
}
case "PhysicalNetworkInterfaceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.PhysicalNetworkInterfaceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPhysicalNetworkInterfaceList(v *[]types.PhysicalNetworkInterface, 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.PhysicalNetworkInterface
if *v == nil {
cv = []types.PhysicalNetworkInterface{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PhysicalNetworkInterface
destAddr := &col
if err := awsAwsjson11_deserializeDocumentPhysicalNetworkInterface(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, 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.ResourceNotFoundException
if *v == nil {
sv = &types.ResourceNotFoundException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentServiceAlreadyStartedException(v **types.ServiceAlreadyStartedException, 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.ServiceAlreadyStartedException
if *v == nil {
sv = &types.ServiceAlreadyStartedException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentServiceConfiguration(v **types.ServiceConfiguration, 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.ServiceConfiguration
if *v == nil {
sv = &types.ServiceConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AllowedHosts":
if err := awsAwsjson11_deserializeDocumentAllowedHosts(&sv.AllowedHosts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentServiceStatus(v **types.ServiceStatus, 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.ServiceStatus
if *v == nil {
sv = &types.ServiceStatus{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceStatusState to be of type string, got %T instead", value)
}
sv.State = types.ServiceStatusState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentServiceStorage(v **types.ServiceStorage, 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.ServiceStorage
if *v == nil {
sv = &types.ServiceStorage{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FreeSpaceBytes":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.FreeSpaceBytes = i64
}
case "TotalSpaceBytes":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.TotalSpaceBytes = i64
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentStaticIpAddressConfiguration(v **types.StaticIpAddressConfiguration, 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.StaticIpAddressConfiguration
if *v == nil {
sv = &types.StaticIpAddressConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "IpAddress":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.IpAddress = ptr.String(jtv)
}
case "Netmask":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.Netmask = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentStringList(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 String to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentTag(v **types.Tag, 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.Tag
if *v == nil {
sv = &types.Tag{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
}
sv.Key = ptr.String(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, 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.Tag
if *v == nil {
cv = []types.Tag{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Tag
destAddr := &col
if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentTimeServiceSettingPersistenceException(v **types.TimeServiceSettingPersistenceException, 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.TimeServiceSettingPersistenceException
if *v == nil {
sv = &types.TimeServiceSettingPersistenceException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentTimeServiceUnavailableException(v **types.TimeServiceUnavailableException, 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.TimeServiceUnavailableException
if *v == nil {
sv = &types.TimeServiceUnavailableException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentTimeSourceStatus(v **types.TimeSourceStatus, 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.TimeSourceStatus
if *v == nil {
sv = &types.TimeSourceStatus{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Address":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
}
sv.Address = ptr.String(jtv)
}
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TimeSourceState to be of type string, got %T instead", value)
}
sv.State = types.TimeSourceState(jtv)
}
case "Stratum":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Stratum = int32(i64)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TimeSourceType to be of type string, got %T instead", value)
}
sv.Type = types.TimeSourceType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentTimeSourceStatusList(v *[]types.TimeSourceStatus, 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.TimeSourceStatus
if *v == nil {
cv = []types.TimeSourceStatus{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TimeSourceStatus
destAddr := &col
if err := awsAwsjson11_deserializeDocumentTimeSourceStatus(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentUnlockStatus(v **types.UnlockStatus, 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.UnlockStatus
if *v == nil {
sv = &types.UnlockStatus{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UnlockStatusState to be of type string, got %T instead", value)
}
sv.State = types.UnlockStatusState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentUnsupportedOperationException(v **types.UnsupportedOperationException, 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.UnsupportedOperationException
if *v == nil {
sv = &types.UnsupportedOperationException{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentVirtualNetworkInterface(v **types.VirtualNetworkInterface, 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.VirtualNetworkInterface
if *v == nil {
sv = &types.VirtualNetworkInterface{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DefaultGateway":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.DefaultGateway = ptr.String(jtv)
}
case "IpAddress":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.IpAddress = ptr.String(jtv)
}
case "IpAddressAssignment":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IpAddressAssignment to be of type string, got %T instead", value)
}
sv.IpAddressAssignment = types.IpAddressAssignment(jtv)
}
case "MacAddress":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.MacAddress = ptr.String(jtv)
}
case "Netmask":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IPv4Address to be of type string, got %T instead", value)
}
sv.Netmask = ptr.String(jtv)
}
case "PhysicalNetworkInterfaceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.PhysicalNetworkInterfaceId = ptr.String(jtv)
}
case "VirtualNetworkInterfaceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
}
sv.VirtualNetworkInterfaceArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentVirtualNetworkInterfaceList(v *[]types.VirtualNetworkInterface, 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.VirtualNetworkInterface
if *v == nil {
cv = []types.VirtualNetworkInterface{}
} else {
cv = *v
}
for _, value := range shape {
var col types.VirtualNetworkInterface
destAddr := &col
if err := awsAwsjson11_deserializeDocumentVirtualNetworkInterface(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeOpDocumentCheckForUpdatesOutput(v **CheckForUpdatesOutput, 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 *CheckForUpdatesOutput
if *v == nil {
sv = &CheckForUpdatesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "InstalledVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.InstalledVersion = ptr.String(jtv)
}
case "LatestVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.LatestVersion = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentConfigureAutoUpdateStrategyOutput(v **ConfigureAutoUpdateStrategyOutput, 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 *ConfigureAutoUpdateStrategyOutput
if *v == nil {
sv = &ConfigureAutoUpdateStrategyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateAutoStartConfigurationOutput(v **CreateAutoStartConfigurationOutput, 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 *CreateAutoStartConfigurationOutput
if *v == nil {
sv = &CreateAutoStartConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoStartConfiguration":
if err := awsAwsjson11_deserializeDocumentAutoStartConfiguration(&sv.AutoStartConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateDirectNetworkInterfaceOutput(v **CreateDirectNetworkInterfaceOutput, 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 *CreateDirectNetworkInterfaceOutput
if *v == nil {
sv = &CreateDirectNetworkInterfaceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DirectNetworkInterface":
if err := awsAwsjson11_deserializeDocumentDirectNetworkInterface(&sv.DirectNetworkInterface, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateTagsOutput(v **CreateTagsOutput, 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 *CreateTagsOutput
if *v == nil {
sv = &CreateTagsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateVirtualNetworkInterfaceOutput(v **CreateVirtualNetworkInterfaceOutput, 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 *CreateVirtualNetworkInterfaceOutput
if *v == nil {
sv = &CreateVirtualNetworkInterfaceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "VirtualNetworkInterface":
if err := awsAwsjson11_deserializeDocumentVirtualNetworkInterface(&sv.VirtualNetworkInterface, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDeleteAutoStartConfigurationOutput(v **DeleteAutoStartConfigurationOutput, 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 *DeleteAutoStartConfigurationOutput
if *v == nil {
sv = &DeleteAutoStartConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDeleteTagsOutput(v **DeleteTagsOutput, 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 *DeleteTagsOutput
if *v == nil {
sv = &DeleteTagsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeAutoStartConfigurationsOutput(v **DescribeAutoStartConfigurationsOutput, 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 *DescribeAutoStartConfigurationsOutput
if *v == nil {
sv = &DescribeAutoStartConfigurationsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoStartConfigurations":
if err := awsAwsjson11_deserializeDocumentAutoStartConfigurationDetailsList(&sv.AutoStartConfigurations, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeAutoUpdateStrategiesOutput(v **DescribeAutoUpdateStrategiesOutput, 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 *DescribeAutoUpdateStrategiesOutput
if *v == nil {
sv = &DescribeAutoUpdateStrategiesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoUpdateStrategies":
if err := awsAwsjson11_deserializeDocumentAutoUpdateStrategyList(&sv.AutoUpdateStrategies, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeClusterOutput(v **DescribeClusterOutput, 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 *DescribeClusterOutput
if *v == nil {
sv = &DescribeClusterOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ClusterId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ClusterId = ptr.String(jtv)
}
case "Devices":
if err := awsAwsjson11_deserializeDocumentDeviceList(&sv.Devices, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeDeviceOutput(v **DescribeDeviceOutput, 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 *DescribeDeviceOutput
if *v == nil {
sv = &DescribeDeviceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ActiveNetworkInterface":
if err := awsAwsjson11_deserializeDocumentNetworkInterface(&sv.ActiveNetworkInterface, value); err != nil {
return err
}
case "ClusterAssociation":
if err := awsAwsjson11_deserializeDocumentClusterAssociation(&sv.ClusterAssociation, value); err != nil {
return err
}
case "DeviceCapacities":
if err := awsAwsjson11_deserializeDocumentCapacityList(&sv.DeviceCapacities, value); err != nil {
return err
}
case "DeviceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DeviceId = ptr.String(jtv)
}
case "DeviceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DeviceType = ptr.String(jtv)
}
case "PhysicalNetworkInterfaces":
if err := awsAwsjson11_deserializeDocumentPhysicalNetworkInterfaceList(&sv.PhysicalNetworkInterfaces, value); err != nil {
return err
}
case "Tags":
if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
return err
}
case "UnlockStatus":
if err := awsAwsjson11_deserializeDocumentUnlockStatus(&sv.UnlockStatus, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeDeviceSoftwareOutput(v **DescribeDeviceSoftwareOutput, 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 *DescribeDeviceSoftwareOutput
if *v == nil {
sv = &DescribeDeviceSoftwareOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "InstalledVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.InstalledVersion = ptr.String(jtv)
}
case "InstallingVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.InstallingVersion = ptr.String(jtv)
}
case "InstallState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InstallState to be of type string, got %T instead", value)
}
sv.InstallState = types.InstallState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeDirectNetworkInterfacesOutput(v **DescribeDirectNetworkInterfacesOutput, 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 *DescribeDirectNetworkInterfacesOutput
if *v == nil {
sv = &DescribeDirectNetworkInterfacesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DirectNetworkInterfaces":
if err := awsAwsjson11_deserializeDocumentDirectNetworkInterfaceList(&sv.DirectNetworkInterfaces, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeFeaturesOutput(v **DescribeFeaturesOutput, 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 *DescribeFeaturesOutput
if *v == nil {
sv = &DescribeFeaturesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "RemoteManagementState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RemoteManagementState to be of type string, got %T instead", value)
}
sv.RemoteManagementState = types.RemoteManagementState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribePhysicalNetworkInterfacesOutput(v **DescribePhysicalNetworkInterfacesOutput, 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 *DescribePhysicalNetworkInterfacesOutput
if *v == nil {
sv = &DescribePhysicalNetworkInterfacesOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "PhysicalNetworkInterfaces":
if err := awsAwsjson11_deserializeDocumentPhysicalNetworkInterfaceList(&sv.PhysicalNetworkInterfaces, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeReturnShippingLabelOutput(v **DescribeReturnShippingLabelOutput, 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 *DescribeReturnShippingLabelOutput
if *v == nil {
sv = &DescribeReturnShippingLabelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ShippingLabelUpdateStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ShippingLabelUpdateStatus to be of type string, got %T instead", value)
}
sv.ShippingLabelUpdateStatus = types.ShippingLabelUpdateStatus(jtv)
}
case "VersionDate":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.VersionDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeServiceOutput(v **DescribeServiceOutput, 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 *DescribeServiceOutput
if *v == nil {
sv = &DescribeServiceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Endpoints":
if err := awsAwsjson11_deserializeDocumentEndpointList(&sv.Endpoints, value); err != nil {
return err
}
case "RoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.RoleArn = ptr.String(jtv)
}
case "ServiceCapacities":
if err := awsAwsjson11_deserializeDocumentCapacityList(&sv.ServiceCapacities, value); err != nil {
return err
}
case "ServiceConfiguration":
if err := awsAwsjson11_deserializeDocumentServiceConfiguration(&sv.ServiceConfiguration, value); err != nil {
return err
}
case "ServiceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ServiceId = ptr.String(jtv)
}
case "Status":
if err := awsAwsjson11_deserializeDocumentServiceStatus(&sv.Status, value); err != nil {
return err
}
case "Storage":
if err := awsAwsjson11_deserializeDocumentServiceStorage(&sv.Storage, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeTagsOutput(v **DescribeTagsOutput, 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 *DescribeTagsOutput
if *v == nil {
sv = &DescribeTagsOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Tags":
if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeTimeSourcesOutput(v **DescribeTimeSourcesOutput, 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 *DescribeTimeSourcesOutput
if *v == nil {
sv = &DescribeTimeSourcesOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Sources":
if err := awsAwsjson11_deserializeDocumentTimeSourceStatusList(&sv.Sources, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeVirtualNetworkInterfacesOutput(v **DescribeVirtualNetworkInterfacesOutput, 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 *DescribeVirtualNetworkInterfacesOutput
if *v == nil {
sv = &DescribeVirtualNetworkInterfacesOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "VirtualNetworkInterfaces":
if err := awsAwsjson11_deserializeDocumentVirtualNetworkInterfaceList(&sv.VirtualNetworkInterfaces, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDownloadUpdatesOutput(v **DownloadUpdatesOutput, 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 *DownloadUpdatesOutput
if *v == nil {
sv = &DownloadUpdatesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetCertificateOutput(v **GetCertificateOutput, 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 *GetCertificateOutput
if *v == nil {
sv = &GetCertificateOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Certificate":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Certificate to be of type string, got %T instead", value)
}
sv.Certificate = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetNotificationConfigurationOutput(v **GetNotificationConfigurationOutput, 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 *GetNotificationConfigurationOutput
if *v == nil {
sv = &GetNotificationConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "BrokerEndPoint":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected BrokerEndpoint to be of type string, got %T instead", value)
}
sv.BrokerEndPoint = ptr.String(jtv)
}
case "Enabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value)
}
sv.Enabled = ptr.Bool(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetReturnShippingLabelOutput(v **GetReturnShippingLabelOutput, 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 *GetReturnShippingLabelOutput
if *v == nil {
sv = &GetReturnShippingLabelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CurrentVersionDate":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CurrentVersionDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetSecretAccessKeyOutput(v **GetSecretAccessKeyOutput, 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 *GetSecretAccessKeyOutput
if *v == nil {
sv = &GetSecretAccessKeyOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.AccessKeyId = ptr.String(jtv)
}
case "SecretAccessKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
}
sv.SecretAccessKey = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentInstallUpdatesOutput(v **InstallUpdatesOutput, 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 *InstallUpdatesOutput
if *v == nil {
sv = &InstallUpdatesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListAccessKeysOutput(v **ListAccessKeysOutput, 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 *ListAccessKeysOutput
if *v == nil {
sv = &ListAccessKeysOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessKeyIds":
if err := awsAwsjson11_deserializeDocumentAccessKeyIdList(&sv.AccessKeyIds, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListCertificatesOutput(v **ListCertificatesOutput, 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 *ListCertificatesOutput
if *v == nil {
sv = &ListCertificatesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Certificates":
if err := awsAwsjson11_deserializeDocumentCertificateSummaryList(&sv.Certificates, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListServicesOutput(v **ListServicesOutput, 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 *ListServicesOutput
if *v == nil {
sv = &ListServicesOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ServiceIds":
if err := awsAwsjson11_deserializeDocumentStringList(&sv.ServiceIds, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentPutNotificationConfigurationOutput(v **PutNotificationConfigurationOutput, 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 *PutNotificationConfigurationOutput
if *v == nil {
sv = &PutNotificationConfigurationOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentRebootDeviceOutput(v **RebootDeviceOutput, 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 *RebootDeviceOutput
if *v == nil {
sv = &RebootDeviceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentSetFeaturesOutput(v **SetFeaturesOutput, 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 *SetFeaturesOutput
if *v == nil {
sv = &SetFeaturesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "RemoteManagementState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RemoteManagementState to be of type string, got %T instead", value)
}
sv.RemoteManagementState = types.RemoteManagementState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentShutdownDeviceOutput(v **ShutdownDeviceOutput, 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 *ShutdownDeviceOutput
if *v == nil {
sv = &ShutdownDeviceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUpdateAutoStartConfigurationOutput(v **UpdateAutoStartConfigurationOutput, 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 *UpdateAutoStartConfigurationOutput
if *v == nil {
sv = &UpdateAutoStartConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoStartConfiguration":
if err := awsAwsjson11_deserializeDocumentAutoStartConfiguration(&sv.AutoStartConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUpdateDirectNetworkInterfaceOutput(v **UpdateDirectNetworkInterfaceOutput, 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 *UpdateDirectNetworkInterfaceOutput
if *v == nil {
sv = &UpdateDirectNetworkInterfaceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DirectNetworkInterface":
if err := awsAwsjson11_deserializeDocumentDirectNetworkInterface(&sv.DirectNetworkInterface, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUpdateTimeServersOutput(v **UpdateTimeServersOutput, 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 *UpdateTimeServersOutput
if *v == nil {
sv = &UpdateTimeServersOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 9,537 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package snowballdevice provides the API client, operations, and parameter types
// for AWS Snowball Device.
package snowballdevice
| 6 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
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/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/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 = "snowballdevice"
}
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 |
eks-anywhere | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package snowballdevice
// goModuleVersion is the tagged release for this module.
const goModuleVersion = "tip"
| 7 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
| 4 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
import (
"bytes"
"context"
"fmt"
"github.com/aws/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/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"
smithyhttp "github.com/aws/smithy-go/transport/http"
"path"
"strings"
)
type awsAwsjson11_serializeOpCheckForUpdates struct {
}
func (*awsAwsjson11_serializeOpCheckForUpdates) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCheckForUpdates) 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.(*CheckForUpdatesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.CheckForUpdates")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCheckForUpdatesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpConfigureAutoUpdateStrategy struct {
}
func (*awsAwsjson11_serializeOpConfigureAutoUpdateStrategy) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpConfigureAutoUpdateStrategy) 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.(*ConfigureAutoUpdateStrategyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.ConfigureAutoUpdateStrategy")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentConfigureAutoUpdateStrategyInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateAutoStartConfiguration struct {
}
func (*awsAwsjson11_serializeOpCreateAutoStartConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateAutoStartConfiguration) 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.(*CreateAutoStartConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.CreateAutoStartConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateAutoStartConfigurationInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateDirectNetworkInterface struct {
}
func (*awsAwsjson11_serializeOpCreateDirectNetworkInterface) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateDirectNetworkInterface) 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.(*CreateDirectNetworkInterfaceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.CreateDirectNetworkInterface")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateDirectNetworkInterfaceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateTags struct {
}
func (*awsAwsjson11_serializeOpCreateTags) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateTags) 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.(*CreateTagsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.CreateTags")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateTagsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateVirtualNetworkInterface struct {
}
func (*awsAwsjson11_serializeOpCreateVirtualNetworkInterface) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateVirtualNetworkInterface) 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.(*CreateVirtualNetworkInterfaceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.CreateVirtualNetworkInterface")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateVirtualNetworkInterfaceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteAutoStartConfiguration struct {
}
func (*awsAwsjson11_serializeOpDeleteAutoStartConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteAutoStartConfiguration) 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.(*DeleteAutoStartConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DeleteAutoStartConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteAutoStartConfigurationInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteDirectNetworkInterface struct {
}
func (*awsAwsjson11_serializeOpDeleteDirectNetworkInterface) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteDirectNetworkInterface) 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.(*DeleteDirectNetworkInterfaceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DeleteDirectNetworkInterface")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteDirectNetworkInterfaceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteTags struct {
}
func (*awsAwsjson11_serializeOpDeleteTags) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteTags) 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.(*DeleteTagsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DeleteTags")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteTagsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteVirtualNetworkInterface struct {
}
func (*awsAwsjson11_serializeOpDeleteVirtualNetworkInterface) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteVirtualNetworkInterface) 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.(*DeleteVirtualNetworkInterfaceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DeleteVirtualNetworkInterface")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteVirtualNetworkInterfaceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeAutoStartConfigurations struct {
}
func (*awsAwsjson11_serializeOpDescribeAutoStartConfigurations) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeAutoStartConfigurations) 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.(*DescribeAutoStartConfigurationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeAutoStartConfigurations")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeAutoStartConfigurationsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeAutoUpdateStrategies struct {
}
func (*awsAwsjson11_serializeOpDescribeAutoUpdateStrategies) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeAutoUpdateStrategies) 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.(*DescribeAutoUpdateStrategiesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeAutoUpdateStrategies")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeAutoUpdateStrategiesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeCluster struct {
}
func (*awsAwsjson11_serializeOpDescribeCluster) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeCluster) 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.(*DescribeClusterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeCluster")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeClusterInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeDevice struct {
}
func (*awsAwsjson11_serializeOpDescribeDevice) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeDevice) 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.(*DescribeDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeDevice")
if request, err = request.SetStream(strings.NewReader(`{}`)); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeDeviceSoftware struct {
}
func (*awsAwsjson11_serializeOpDescribeDeviceSoftware) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeDeviceSoftware) 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.(*DescribeDeviceSoftwareInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeDeviceSoftware")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeDeviceSoftwareInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeDirectNetworkInterfaces struct {
}
func (*awsAwsjson11_serializeOpDescribeDirectNetworkInterfaces) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeDirectNetworkInterfaces) 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.(*DescribeDirectNetworkInterfacesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeDirectNetworkInterfaces")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeDirectNetworkInterfacesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeFeatures struct {
}
func (*awsAwsjson11_serializeOpDescribeFeatures) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeFeatures) 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.(*DescribeFeaturesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeFeatures")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeFeaturesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribePhysicalNetworkInterfaces struct {
}
func (*awsAwsjson11_serializeOpDescribePhysicalNetworkInterfaces) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribePhysicalNetworkInterfaces) 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.(*DescribePhysicalNetworkInterfacesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribePhysicalNetworkInterfaces")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribePhysicalNetworkInterfacesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeReturnShippingLabel struct {
}
func (*awsAwsjson11_serializeOpDescribeReturnShippingLabel) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeReturnShippingLabel) 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.(*DescribeReturnShippingLabelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeReturnShippingLabel")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeReturnShippingLabelInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeService struct {
}
func (*awsAwsjson11_serializeOpDescribeService) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeService) 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.(*DescribeServiceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeService")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeServiceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeTags struct {
}
func (*awsAwsjson11_serializeOpDescribeTags) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeTags) 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.(*DescribeTagsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeTags")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeTagsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeTimeSources struct {
}
func (*awsAwsjson11_serializeOpDescribeTimeSources) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeTimeSources) 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.(*DescribeTimeSourcesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeTimeSources")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeTimeSourcesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeVirtualNetworkInterfaces struct {
}
func (*awsAwsjson11_serializeOpDescribeVirtualNetworkInterfaces) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeVirtualNetworkInterfaces) 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.(*DescribeVirtualNetworkInterfacesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DescribeVirtualNetworkInterfaces")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeVirtualNetworkInterfacesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDownloadUpdates struct {
}
func (*awsAwsjson11_serializeOpDownloadUpdates) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDownloadUpdates) 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.(*DownloadUpdatesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.DownloadUpdates")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDownloadUpdatesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetCertificate struct {
}
func (*awsAwsjson11_serializeOpGetCertificate) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetCertificate) 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.(*GetCertificateInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.GetCertificate")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetCertificateInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetNotificationConfiguration struct {
}
func (*awsAwsjson11_serializeOpGetNotificationConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetNotificationConfiguration) 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.(*GetNotificationConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.GetNotificationConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetNotificationConfigurationInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetReturnShippingLabel struct {
}
func (*awsAwsjson11_serializeOpGetReturnShippingLabel) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetReturnShippingLabel) 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.(*GetReturnShippingLabelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.GetReturnShippingLabel")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetReturnShippingLabelInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetSecretAccessKey struct {
}
func (*awsAwsjson11_serializeOpGetSecretAccessKey) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetSecretAccessKey) 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.(*GetSecretAccessKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.GetSecretAccessKey")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetSecretAccessKeyInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpInstallUpdates struct {
}
func (*awsAwsjson11_serializeOpInstallUpdates) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpInstallUpdates) 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.(*InstallUpdatesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.InstallUpdates")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentInstallUpdatesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListAccessKeys struct {
}
func (*awsAwsjson11_serializeOpListAccessKeys) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListAccessKeys) 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.(*ListAccessKeysInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.ListAccessKeys")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListAccessKeysInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListCertificates struct {
}
func (*awsAwsjson11_serializeOpListCertificates) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListCertificates) 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.(*ListCertificatesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.ListCertificates")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListCertificatesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListServices struct {
}
func (*awsAwsjson11_serializeOpListServices) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListServices) 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.(*ListServicesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.ListServices")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListServicesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPutNotificationConfiguration struct {
}
func (*awsAwsjson11_serializeOpPutNotificationConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPutNotificationConfiguration) 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.(*PutNotificationConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.PutNotificationConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPutNotificationConfigurationInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpRebootDevice struct {
}
func (*awsAwsjson11_serializeOpRebootDevice) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpRebootDevice) 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.(*RebootDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.RebootDevice")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentRebootDeviceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpSetFeatures struct {
}
func (*awsAwsjson11_serializeOpSetFeatures) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpSetFeatures) 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.(*SetFeaturesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.SetFeatures")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentSetFeaturesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpShutdownDevice struct {
}
func (*awsAwsjson11_serializeOpShutdownDevice) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpShutdownDevice) 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.(*ShutdownDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.ShutdownDevice")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentShutdownDeviceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStartService struct {
}
func (*awsAwsjson11_serializeOpStartService) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStartService) 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.(*StartServiceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.StartService")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStartServiceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpStopService struct {
}
func (*awsAwsjson11_serializeOpStopService) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpStopService) 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.(*StopServiceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.StopService")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentStopServiceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateAutoStartConfiguration struct {
}
func (*awsAwsjson11_serializeOpUpdateAutoStartConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateAutoStartConfiguration) 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.(*UpdateAutoStartConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.UpdateAutoStartConfiguration")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateAutoStartConfigurationInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateDirectNetworkInterface struct {
}
func (*awsAwsjson11_serializeOpUpdateDirectNetworkInterface) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateDirectNetworkInterface) 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.(*UpdateDirectNetworkInterfaceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.UpdateDirectNetworkInterface")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateDirectNetworkInterfaceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateTimeServers struct {
}
func (*awsAwsjson11_serializeOpUpdateTimeServers) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateTimeServers) 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.(*UpdateTimeServersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.UpdateTimeServers")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateTimeServersInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateVirtualNetworkInterface struct {
}
func (*awsAwsjson11_serializeOpUpdateVirtualNetworkInterface) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateVirtualNetworkInterface) 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.(*UpdateVirtualNetworkInterfaceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("SnowballDevice_20171127.UpdateVirtualNetworkInterface")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateVirtualNetworkInterfaceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsAwsjson11_serializeDocumentAllowedHosts(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 awsAwsjson11_serializeDocumentArnList(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 awsAwsjson11_serializeDocumentServiceConfiguration(v *types.ServiceConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AllowedHosts != nil {
ok := object.Key("AllowedHosts")
if err := awsAwsjson11_serializeDocumentAllowedHosts(v.AllowedHosts, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentStaticIpAddressConfiguration(v *types.StaticIpAddressConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IpAddress != nil {
ok := object.Key("IpAddress")
ok.String(*v.IpAddress)
}
if v.Netmask != nil {
ok := object.Key("Netmask")
ok.String(*v.Netmask)
}
return nil
}
func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Key != nil {
ok := object.Key("Key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("Value")
ok.String(*v.Value)
}
return nil
}
func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentTimeServerList(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 awsAwsjson11_serializeOpDocumentCheckForUpdatesInput(v *CheckForUpdatesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentConfigureAutoUpdateStrategyInput(v *ConfigureAutoUpdateStrategyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AutoCheck {
ok := object.Key("AutoCheck")
ok.Boolean(v.AutoCheck)
}
if v.AutoCheckFrequency != nil {
ok := object.Key("AutoCheckFrequency")
ok.String(*v.AutoCheckFrequency)
}
if v.AutoDownload {
ok := object.Key("AutoDownload")
ok.Boolean(v.AutoDownload)
}
if v.AutoDownloadFrequency != nil {
ok := object.Key("AutoDownloadFrequency")
ok.String(*v.AutoDownloadFrequency)
}
if v.AutoInstall {
ok := object.Key("AutoInstall")
ok.Boolean(v.AutoInstall)
}
if v.AutoInstallFrequency != nil {
ok := object.Key("AutoInstallFrequency")
ok.String(*v.AutoInstallFrequency)
}
if v.AutoReboot {
ok := object.Key("AutoReboot")
ok.Boolean(v.AutoReboot)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateAutoStartConfigurationInput(v *CreateAutoStartConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.IpAddressAssignment) > 0 {
ok := object.Key("IpAddressAssignment")
ok.String(string(v.IpAddressAssignment))
}
if v.LaunchTemplateId != nil {
ok := object.Key("LaunchTemplateId")
ok.String(*v.LaunchTemplateId)
}
if v.LaunchTemplateVersion != nil {
ok := object.Key("LaunchTemplateVersion")
ok.String(*v.LaunchTemplateVersion)
}
if len(v.PhysicalConnectorType) > 0 {
ok := object.Key("PhysicalConnectorType")
ok.String(string(v.PhysicalConnectorType))
}
if v.StaticIpAddressConfiguration != nil {
ok := object.Key("StaticIpAddressConfiguration")
if err := awsAwsjson11_serializeDocumentStaticIpAddressConfiguration(v.StaticIpAddressConfiguration, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateDirectNetworkInterfaceInput(v *CreateDirectNetworkInterfaceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InstanceId != nil {
ok := object.Key("InstanceId")
ok.String(*v.InstanceId)
}
if v.MacAddress != nil {
ok := object.Key("MacAddress")
ok.String(*v.MacAddress)
}
if v.PhysicalNetworkInterfaceId != nil {
ok := object.Key("PhysicalNetworkInterfaceId")
ok.String(*v.PhysicalNetworkInterfaceId)
}
if v.VlanId != nil {
ok := object.Key("VlanId")
ok.Integer(*v.VlanId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateTagsInput(v *CreateTagsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateVirtualNetworkInterfaceInput(v *CreateVirtualNetworkInterfaceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.IpAddressAssignment) > 0 {
ok := object.Key("IpAddressAssignment")
ok.String(string(v.IpAddressAssignment))
}
if v.PhysicalNetworkInterfaceId != nil {
ok := object.Key("PhysicalNetworkInterfaceId")
ok.String(*v.PhysicalNetworkInterfaceId)
}
if v.StaticIpAddressConfiguration != nil {
ok := object.Key("StaticIpAddressConfiguration")
if err := awsAwsjson11_serializeDocumentStaticIpAddressConfiguration(v.StaticIpAddressConfiguration, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteAutoStartConfigurationInput(v *DeleteAutoStartConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AutoStartConfigurationArn != nil {
ok := object.Key("AutoStartConfigurationArn")
ok.String(*v.AutoStartConfigurationArn)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteDirectNetworkInterfaceInput(v *DeleteDirectNetworkInterfaceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DirectNetworkInterfaceArn != nil {
ok := object.Key("DirectNetworkInterfaceArn")
ok.String(*v.DirectNetworkInterfaceArn)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteTagsInput(v *DeleteTagsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteVirtualNetworkInterfaceInput(v *DeleteVirtualNetworkInterfaceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.VirtualNetworkInterfaceArn != nil {
ok := object.Key("VirtualNetworkInterfaceArn")
ok.String(*v.VirtualNetworkInterfaceArn)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeAutoStartConfigurationsInput(v *DescribeAutoStartConfigurationsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeAutoUpdateStrategiesInput(v *DescribeAutoUpdateStrategiesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeClusterInput(v *DescribeClusterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeDeviceSoftwareInput(v *DescribeDeviceSoftwareInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeDirectNetworkInterfacesInput(v *DescribeDirectNetworkInterfacesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeFeaturesInput(v *DescribeFeaturesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentDescribePhysicalNetworkInterfacesInput(v *DescribePhysicalNetworkInterfacesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeReturnShippingLabelInput(v *DescribeReturnShippingLabelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeServiceInput(v *DescribeServiceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ServiceId != nil {
ok := object.Key("ServiceId")
ok.String(*v.ServiceId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeTagsInput(v *DescribeTagsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeTimeSourcesInput(v *DescribeTimeSourcesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeVirtualNetworkInterfacesInput(v *DescribeVirtualNetworkInterfacesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDownloadUpdatesInput(v *DownloadUpdatesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentGetCertificateInput(v *GetCertificateInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CertificateArn != nil {
ok := object.Key("CertificateArn")
ok.String(*v.CertificateArn)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetNotificationConfigurationInput(v *GetNotificationConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ServiceId != nil {
ok := object.Key("ServiceId")
ok.String(*v.ServiceId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetReturnShippingLabelInput(v *GetReturnShippingLabelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentGetSecretAccessKeyInput(v *GetSecretAccessKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccessKeyId != nil {
ok := object.Key("AccessKeyId")
ok.String(*v.AccessKeyId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentInstallUpdatesInput(v *InstallUpdatesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentListAccessKeysInput(v *ListAccessKeysInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListCertificatesInput(v *ListCertificatesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListServicesInput(v *ListServicesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentPutNotificationConfigurationInput(v *PutNotificationConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BrokerEndpoint != nil {
ok := object.Key("BrokerEndpoint")
ok.String(*v.BrokerEndpoint)
}
if v.CaCertificate != nil {
ok := object.Key("CaCertificate")
ok.String(*v.CaCertificate)
}
if v.Enabled != nil {
ok := object.Key("Enabled")
ok.Boolean(*v.Enabled)
}
if v.ServiceId != nil {
ok := object.Key("ServiceId")
ok.String(*v.ServiceId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentRebootDeviceInput(v *RebootDeviceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentSetFeaturesInput(v *SetFeaturesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.RemoteManagementState) > 0 {
ok := object.Key("RemoteManagementState")
ok.String(string(v.RemoteManagementState))
}
return nil
}
func awsAwsjson11_serializeOpDocumentShutdownDeviceInput(v *ShutdownDeviceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentStartServiceInput(v *StartServiceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ServiceConfiguration != nil {
ok := object.Key("ServiceConfiguration")
if err := awsAwsjson11_serializeDocumentServiceConfiguration(v.ServiceConfiguration, ok); err != nil {
return err
}
}
if v.ServiceId != nil {
ok := object.Key("ServiceId")
ok.String(*v.ServiceId)
}
if v.VirtualNetworkInterfaceArns != nil {
ok := object.Key("VirtualNetworkInterfaceArns")
if err := awsAwsjson11_serializeDocumentArnList(v.VirtualNetworkInterfaceArns, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentStopServiceInput(v *StopServiceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ServiceId != nil {
ok := object.Key("ServiceId")
ok.String(*v.ServiceId)
}
if v.Terminate {
ok := object.Key("Terminate")
ok.Boolean(v.Terminate)
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateAutoStartConfigurationInput(v *UpdateAutoStartConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AutoStartConfigurationArn != nil {
ok := object.Key("AutoStartConfigurationArn")
ok.String(*v.AutoStartConfigurationArn)
}
if v.Enabled != nil {
ok := object.Key("Enabled")
ok.Boolean(*v.Enabled)
}
if len(v.IpAddressAssignment) > 0 {
ok := object.Key("IpAddressAssignment")
ok.String(string(v.IpAddressAssignment))
}
if v.LaunchTemplateId != nil {
ok := object.Key("LaunchTemplateId")
ok.String(*v.LaunchTemplateId)
}
if v.LaunchTemplateVersion != nil {
ok := object.Key("LaunchTemplateVersion")
ok.String(*v.LaunchTemplateVersion)
}
if len(v.PhysicalConnectorType) > 0 {
ok := object.Key("PhysicalConnectorType")
ok.String(string(v.PhysicalConnectorType))
}
if v.StaticIpAddressConfiguration != nil {
ok := object.Key("StaticIpAddressConfiguration")
if err := awsAwsjson11_serializeDocumentStaticIpAddressConfiguration(v.StaticIpAddressConfiguration, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateDirectNetworkInterfaceInput(v *UpdateDirectNetworkInterfaceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Detach {
ok := object.Key("Detach")
ok.Boolean(v.Detach)
}
if v.DirectNetworkInterfaceArn != nil {
ok := object.Key("DirectNetworkInterfaceArn")
ok.String(*v.DirectNetworkInterfaceArn)
}
if v.InstanceId != nil {
ok := object.Key("InstanceId")
ok.String(*v.InstanceId)
}
if v.MacAddress != nil {
ok := object.Key("MacAddress")
ok.String(*v.MacAddress)
}
if v.VlanId != nil {
ok := object.Key("VlanId")
ok.Integer(*v.VlanId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateTimeServersInput(v *UpdateTimeServersInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Servers != nil {
ok := object.Key("Servers")
if err := awsAwsjson11_serializeDocumentTimeServerList(v.Servers, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateVirtualNetworkInterfaceInput(v *UpdateVirtualNetworkInterfaceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.IpAddressAssignment) > 0 {
ok := object.Key("IpAddressAssignment")
ok.String(string(v.IpAddressAssignment))
}
if v.StaticIpAddressConfiguration != nil {
ok := object.Key("StaticIpAddressConfiguration")
if err := awsAwsjson11_serializeDocumentStaticIpAddressConfiguration(v.StaticIpAddressConfiguration, ok); err != nil {
return err
}
}
if v.VirtualNetworkInterfaceArn != nil {
ok := object.Key("VirtualNetworkInterfaceArn")
ok.String(*v.VirtualNetworkInterfaceArn)
}
return nil
}
| 3,046 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package snowballdevice
import (
"context"
"fmt"
"github.com/aws/eks-anywhere/internal/aws-sdk-go-v2/service/snowballdevice/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpCreateAutoStartConfiguration struct {
}
func (*validateOpCreateAutoStartConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateAutoStartConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateAutoStartConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateAutoStartConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateDirectNetworkInterface struct {
}
func (*validateOpCreateDirectNetworkInterface) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateDirectNetworkInterface) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateDirectNetworkInterfaceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateDirectNetworkInterfaceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateTags struct {
}
func (*validateOpCreateTags) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateTagsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateTagsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateVirtualNetworkInterface struct {
}
func (*validateOpCreateVirtualNetworkInterface) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateVirtualNetworkInterface) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateVirtualNetworkInterfaceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateVirtualNetworkInterfaceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteAutoStartConfiguration struct {
}
func (*validateOpDeleteAutoStartConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteAutoStartConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteAutoStartConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteAutoStartConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteDirectNetworkInterface struct {
}
func (*validateOpDeleteDirectNetworkInterface) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteDirectNetworkInterface) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteDirectNetworkInterfaceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteDirectNetworkInterfaceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteTags struct {
}
func (*validateOpDeleteTags) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteTagsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteTagsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteVirtualNetworkInterface struct {
}
func (*validateOpDeleteVirtualNetworkInterface) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteVirtualNetworkInterface) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteVirtualNetworkInterfaceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteVirtualNetworkInterfaceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeService struct {
}
func (*validateOpDescribeService) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeServiceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeServiceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetCertificate struct {
}
func (*validateOpGetCertificate) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetCertificateInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetCertificateInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetNotificationConfiguration struct {
}
func (*validateOpGetNotificationConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetNotificationConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetNotificationConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetNotificationConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetSecretAccessKey struct {
}
func (*validateOpGetSecretAccessKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetSecretAccessKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetSecretAccessKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetSecretAccessKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutNotificationConfiguration struct {
}
func (*validateOpPutNotificationConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutNotificationConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutNotificationConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutNotificationConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSetFeatures struct {
}
func (*validateOpSetFeatures) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSetFeatures) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SetFeaturesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSetFeaturesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateAutoStartConfiguration struct {
}
func (*validateOpUpdateAutoStartConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateAutoStartConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateAutoStartConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateAutoStartConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateDirectNetworkInterface struct {
}
func (*validateOpUpdateDirectNetworkInterface) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateDirectNetworkInterface) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateDirectNetworkInterfaceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateDirectNetworkInterfaceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateVirtualNetworkInterface struct {
}
func (*validateOpUpdateVirtualNetworkInterface) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateVirtualNetworkInterface) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateVirtualNetworkInterfaceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateVirtualNetworkInterfaceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpCreateAutoStartConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateAutoStartConfiguration{}, middleware.After)
}
func addOpCreateDirectNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateDirectNetworkInterface{}, middleware.After)
}
func addOpCreateTagsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateTags{}, middleware.After)
}
func addOpCreateVirtualNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateVirtualNetworkInterface{}, middleware.After)
}
func addOpDeleteAutoStartConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteAutoStartConfiguration{}, middleware.After)
}
func addOpDeleteDirectNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteDirectNetworkInterface{}, middleware.After)
}
func addOpDeleteTagsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteTags{}, middleware.After)
}
func addOpDeleteVirtualNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteVirtualNetworkInterface{}, middleware.After)
}
func addOpDescribeServiceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeService{}, middleware.After)
}
func addOpGetCertificateValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetCertificate{}, middleware.After)
}
func addOpGetNotificationConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetNotificationConfiguration{}, middleware.After)
}
func addOpGetSecretAccessKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetSecretAccessKey{}, middleware.After)
}
func addOpPutNotificationConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutNotificationConfiguration{}, middleware.After)
}
func addOpSetFeaturesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSetFeatures{}, middleware.After)
}
func addOpUpdateAutoStartConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateAutoStartConfiguration{}, middleware.After)
}
func addOpUpdateDirectNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateDirectNetworkInterface{}, middleware.After)
}
func addOpUpdateVirtualNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateVirtualNetworkInterface{}, middleware.After)
}
func validateStaticIpAddressConfiguration(v *types.StaticIpAddressConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StaticIpAddressConfiguration"}
if v.IpAddress == nil {
invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
}
if v.Netmask == nil {
invalidParams.Add(smithy.NewErrParamRequired("Netmask"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateAutoStartConfigurationInput(v *CreateAutoStartConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateAutoStartConfigurationInput"}
if len(v.PhysicalConnectorType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PhysicalConnectorType"))
}
if len(v.IpAddressAssignment) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("IpAddressAssignment"))
}
if v.StaticIpAddressConfiguration != nil {
if err := validateStaticIpAddressConfiguration(v.StaticIpAddressConfiguration); err != nil {
invalidParams.AddNested("StaticIpAddressConfiguration", err.(smithy.InvalidParamsError))
}
}
if v.LaunchTemplateId == nil {
invalidParams.Add(smithy.NewErrParamRequired("LaunchTemplateId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateDirectNetworkInterfaceInput(v *CreateDirectNetworkInterfaceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateDirectNetworkInterfaceInput"}
if v.PhysicalNetworkInterfaceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PhysicalNetworkInterfaceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateTagsInput(v *CreateTagsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateTagsInput"}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateVirtualNetworkInterfaceInput(v *CreateVirtualNetworkInterfaceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualNetworkInterfaceInput"}
if v.PhysicalNetworkInterfaceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PhysicalNetworkInterfaceId"))
}
if len(v.IpAddressAssignment) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("IpAddressAssignment"))
}
if v.StaticIpAddressConfiguration != nil {
if err := validateStaticIpAddressConfiguration(v.StaticIpAddressConfiguration); err != nil {
invalidParams.AddNested("StaticIpAddressConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteAutoStartConfigurationInput(v *DeleteAutoStartConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteAutoStartConfigurationInput"}
if v.AutoStartConfigurationArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("AutoStartConfigurationArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteDirectNetworkInterfaceInput(v *DeleteDirectNetworkInterfaceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteDirectNetworkInterfaceInput"}
if v.DirectNetworkInterfaceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("DirectNetworkInterfaceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteTagsInput(v *DeleteTagsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsInput"}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteVirtualNetworkInterfaceInput(v *DeleteVirtualNetworkInterfaceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualNetworkInterfaceInput"}
if v.VirtualNetworkInterfaceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("VirtualNetworkInterfaceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeServiceInput(v *DescribeServiceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeServiceInput"}
if v.ServiceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetCertificateInput(v *GetCertificateInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetCertificateInput"}
if v.CertificateArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetNotificationConfigurationInput(v *GetNotificationConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetNotificationConfigurationInput"}
if v.ServiceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetSecretAccessKeyInput(v *GetSecretAccessKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetSecretAccessKeyInput"}
if v.AccessKeyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AccessKeyId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutNotificationConfigurationInput(v *PutNotificationConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutNotificationConfigurationInput"}
if v.ServiceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
}
if v.Enabled == nil {
invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSetFeaturesInput(v *SetFeaturesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SetFeaturesInput"}
if len(v.RemoteManagementState) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("RemoteManagementState"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateAutoStartConfigurationInput(v *UpdateAutoStartConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateAutoStartConfigurationInput"}
if v.AutoStartConfigurationArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("AutoStartConfigurationArn"))
}
if v.StaticIpAddressConfiguration != nil {
if err := validateStaticIpAddressConfiguration(v.StaticIpAddressConfiguration); err != nil {
invalidParams.AddNested("StaticIpAddressConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateDirectNetworkInterfaceInput(v *UpdateDirectNetworkInterfaceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateDirectNetworkInterfaceInput"}
if v.DirectNetworkInterfaceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("DirectNetworkInterfaceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateVirtualNetworkInterfaceInput(v *UpdateVirtualNetworkInterfaceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualNetworkInterfaceInput"}
if v.VirtualNetworkInterfaceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("VirtualNetworkInterfaceArn"))
}
if len(v.IpAddressAssignment) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("IpAddressAssignment"))
}
if v.StaticIpAddressConfiguration != nil {
if err := validateStaticIpAddressConfiguration(v.StaticIpAddressConfiguration); err != nil {
invalidParams.AddNested("StaticIpAddressConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 728 |
eks-anywhere | 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/eks-anywhere/internal/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 Snowball Device 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
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+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "snowballdevice.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "snowballdevice-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "snowballdevice-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "snowballdevice.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "snowballdevice.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "snowballdevice-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "snowballdevice-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "snowballdevice.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "snowballdevice-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "snowballdevice.{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: "snowballdevice-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "snowballdevice.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "snowballdevice.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "snowballdevice-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "snowballdevice-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "snowballdevice.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 251 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type ClusterAssociationState string
// Enum values for ClusterAssociationState.
const (
ClusterAssociationStateAssociated ClusterAssociationState = "ASSOCIATED"
ClusterAssociationStateAssociating ClusterAssociationState = "ASSOCIATING"
ClusterAssociationStateDisassociated ClusterAssociationState = "DISASSOCIATED"
ClusterAssociationStateDisassociating ClusterAssociationState = "DISASSOCIATING"
)
// Values returns all known values for ClusterAssociationState. 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 (ClusterAssociationState) Values() []ClusterAssociationState {
return []ClusterAssociationState{
"ASSOCIATED",
"ASSOCIATING",
"DISASSOCIATED",
"DISASSOCIATING",
}
}
type DirectNetworkDriver string
// Enum values for DirectNetworkDriver.
const (
DirectNetworkDriverIxgbevf DirectNetworkDriver = "ixgbevf"
DirectNetworkDriverMlx5Core DirectNetworkDriver = "mlx5_core"
)
// Values returns all known values for DirectNetworkDriver. 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 (DirectNetworkDriver) Values() []DirectNetworkDriver {
return []DirectNetworkDriver{
"ixgbevf",
"mlx5_core",
}
}
type InstallState string
// Enum values for InstallState.
const (
InstallStateNa InstallState = "NA"
InstallStateDecrypting InstallState = "DECRYPTING"
InstallStateDecryptFailed InstallState = "DECRYPT_FAILED"
InstallStateDownloading InstallState = "DOWNLOADING"
InstallStateDownloadFailed InstallState = "DOWNLOAD_FAILED"
InstallStateDownloaded InstallState = "DOWNLOADED"
InstallStateInstalling InstallState = "INSTALLING"
InstallStateRequireReboot InstallState = "REQUIRE_REBOOT"
InstallStateInstallFailed InstallState = "INSTALL_FAILED"
)
// Values returns all known values for InstallState. 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 (InstallState) Values() []InstallState {
return []InstallState{
"NA",
"DECRYPTING",
"DECRYPT_FAILED",
"DOWNLOADING",
"DOWNLOAD_FAILED",
"DOWNLOADED",
"INSTALLING",
"REQUIRE_REBOOT",
"INSTALL_FAILED",
}
}
type IpAddressAssignment string
// Enum values for IpAddressAssignment.
const (
IpAddressAssignmentDhcp IpAddressAssignment = "DHCP"
IpAddressAssignmentStatic IpAddressAssignment = "STATIC"
)
// Values returns all known values for IpAddressAssignment. 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 (IpAddressAssignment) Values() []IpAddressAssignment {
return []IpAddressAssignment{
"DHCP",
"STATIC",
}
}
type NetworkReachabilityState string
// Enum values for NetworkReachabilityState.
const (
NetworkReachabilityStateReachable NetworkReachabilityState = "REACHABLE"
NetworkReachabilityStateUnreachable NetworkReachabilityState = "UNREACHABLE"
)
// Values returns all known values for NetworkReachabilityState. 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 (NetworkReachabilityState) Values() []NetworkReachabilityState {
return []NetworkReachabilityState{
"REACHABLE",
"UNREACHABLE",
}
}
type PhysicalConnectorType string
// Enum values for PhysicalConnectorType.
const (
PhysicalConnectorTypeRj45 PhysicalConnectorType = "RJ45"
PhysicalConnectorTypeRj452 PhysicalConnectorType = "RJ45_2"
PhysicalConnectorTypeSfpPlus PhysicalConnectorType = "SFP_PLUS"
PhysicalConnectorTypeQsfp PhysicalConnectorType = "QSFP"
PhysicalConnectorTypeWifi PhysicalConnectorType = "WIFI"
)
// Values returns all known values for PhysicalConnectorType. 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 (PhysicalConnectorType) Values() []PhysicalConnectorType {
return []PhysicalConnectorType{
"RJ45",
"RJ45_2",
"SFP_PLUS",
"QSFP",
"WIFI",
}
}
type RemoteManagementState string
// Enum values for RemoteManagementState.
const (
RemoteManagementStateInstalledAutostart RemoteManagementState = "INSTALLED_AUTOSTART"
RemoteManagementStateInstalledOnly RemoteManagementState = "INSTALLED_ONLY"
)
// Values returns all known values for RemoteManagementState. 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 (RemoteManagementState) Values() []RemoteManagementState {
return []RemoteManagementState{
"INSTALLED_AUTOSTART",
"INSTALLED_ONLY",
}
}
type ServiceStatusState string
// Enum values for ServiceStatusState.
const (
ServiceStatusStateInactive ServiceStatusState = "INACTIVE"
ServiceStatusStateDeactivating ServiceStatusState = "DEACTIVATING"
ServiceStatusStateDeactivated ServiceStatusState = "DEACTIVATED"
ServiceStatusStateActivating ServiceStatusState = "ACTIVATING"
ServiceStatusStateActive ServiceStatusState = "ACTIVE"
)
// Values returns all known values for ServiceStatusState. 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 (ServiceStatusState) Values() []ServiceStatusState {
return []ServiceStatusState{
"INACTIVE",
"DEACTIVATING",
"DEACTIVATED",
"ACTIVATING",
"ACTIVE",
}
}
type ShippingLabelUpdateStatus string
// Enum values for ShippingLabelUpdateStatus.
const (
ShippingLabelUpdateStatusLabelStateUnavailable ShippingLabelUpdateStatus = "LABEL_STATE_UNAVAILABLE"
ShippingLabelUpdateStatusLabelFound ShippingLabelUpdateStatus = "LABEL_FOUND"
ShippingLabelUpdateStatusLabelDownloaded ShippingLabelUpdateStatus = "LABEL_DOWNLOADED"
ShippingLabelUpdateStatusLabelDownloadFailed ShippingLabelUpdateStatus = "LABEL_DOWNLOAD_FAILED"
ShippingLabelUpdateStatusLabelDecrypted ShippingLabelUpdateStatus = "LABEL_DECRYPTED"
ShippingLabelUpdateStatusLabelDecryptedFailed ShippingLabelUpdateStatus = "LABEL_DECRYPTED_FAILED"
ShippingLabelUpdateStatusLabelCopyFailed ShippingLabelUpdateStatus = "LABEL_COPY_FAILED"
ShippingLabelUpdateStatusLabelReadyForDisplay ShippingLabelUpdateStatus = "LABEL_READY_FOR_DISPLAY"
ShippingLabelUpdateStatusDisplayRebooting ShippingLabelUpdateStatus = "DISPLAY_REBOOTING"
ShippingLabelUpdateStatusLabelDisplayTimeout ShippingLabelUpdateStatus = "LABEL_DISPLAY_TIMEOUT"
ShippingLabelUpdateStatusLabelDisplayIgnored ShippingLabelUpdateStatus = "LABEL_DISPLAY_IGNORED"
ShippingLabelUpdateStatusLabelOnDisplay ShippingLabelUpdateStatus = "LABEL_ON_DISPLAY"
)
// Values returns all known values for ShippingLabelUpdateStatus. 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 (ShippingLabelUpdateStatus) Values() []ShippingLabelUpdateStatus {
return []ShippingLabelUpdateStatus{
"LABEL_STATE_UNAVAILABLE",
"LABEL_FOUND",
"LABEL_DOWNLOADED",
"LABEL_DOWNLOAD_FAILED",
"LABEL_DECRYPTED",
"LABEL_DECRYPTED_FAILED",
"LABEL_COPY_FAILED",
"LABEL_READY_FOR_DISPLAY",
"DISPLAY_REBOOTING",
"LABEL_DISPLAY_TIMEOUT",
"LABEL_DISPLAY_IGNORED",
"LABEL_ON_DISPLAY",
}
}
type TimeSourceState string
// Enum values for TimeSourceState.
const (
TimeSourceStateCurrent TimeSourceState = "CURRENT"
TimeSourceStateCombined TimeSourceState = "COMBINED"
TimeSourceStateExcluded TimeSourceState = "EXCLUDED"
TimeSourceStateLost TimeSourceState = "LOST"
TimeSourceStateUnacceptable TimeSourceState = "UNACCEPTABLE"
)
// Values returns all known values for TimeSourceState. 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 (TimeSourceState) Values() []TimeSourceState {
return []TimeSourceState{
"CURRENT",
"COMBINED",
"EXCLUDED",
"LOST",
"UNACCEPTABLE",
}
}
type TimeSourceType string
// Enum values for TimeSourceType.
const (
TimeSourceTypeServer TimeSourceType = "SERVER"
TimeSourceTypePeer TimeSourceType = "PEER"
)
// Values returns all known values for TimeSourceType. 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 (TimeSourceType) Values() []TimeSourceType {
return []TimeSourceType{
"SERVER",
"PEER",
}
}
type UnlockStatusState string
// Enum values for UnlockStatusState.
const (
UnlockStatusStateLocked UnlockStatusState = "LOCKED"
UnlockStatusStateUnlocked UnlockStatusState = "UNLOCKED"
UnlockStatusStateUnlocking UnlockStatusState = "UNLOCKING"
)
// Values returns all known values for UnlockStatusState. 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 (UnlockStatusState) Values() []UnlockStatusState {
return []UnlockStatusState{
"LOCKED",
"UNLOCKED",
"UNLOCKING",
}
}
| 278 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
type IncorrectDeviceStateException struct {
Message *string
noSmithyDocumentSerde
}
func (e *IncorrectDeviceStateException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *IncorrectDeviceStateException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *IncorrectDeviceStateException) ErrorCode() string { return "IncorrectDeviceStateException" }
func (e *IncorrectDeviceStateException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type IncorrectDeviceUpdateStateException struct {
Message *string
noSmithyDocumentSerde
}
func (e *IncorrectDeviceUpdateStateException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *IncorrectDeviceUpdateStateException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *IncorrectDeviceUpdateStateException) ErrorCode() string {
return "IncorrectDeviceUpdateStateException"
}
func (e *IncorrectDeviceUpdateStateException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type IncorrectRemoteManagementStateException struct {
Message *string
noSmithyDocumentSerde
}
func (e *IncorrectRemoteManagementStateException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *IncorrectRemoteManagementStateException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *IncorrectRemoteManagementStateException) ErrorCode() string {
return "IncorrectRemoteManagementStateException"
}
func (e *IncorrectRemoteManagementStateException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type InternalFailureException struct {
Message *string
noSmithyDocumentSerde
}
func (e *InternalFailureException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalFailureException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalFailureException) ErrorCode() string { return "InternalFailureException" }
func (e *InternalFailureException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidPaginationTokenException struct {
Message *string
noSmithyDocumentSerde
}
func (e *InvalidPaginationTokenException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidPaginationTokenException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidPaginationTokenException) ErrorCode() string {
return "InvalidPaginationTokenException"
}
func (e *InvalidPaginationTokenException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidParameterCombinationException struct {
Message *string
noSmithyDocumentSerde
}
func (e *InvalidParameterCombinationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidParameterCombinationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidParameterCombinationException) ErrorCode() string {
return "InvalidParameterCombinationException"
}
func (e *InvalidParameterCombinationException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type InvalidParameterValueException struct {
Message *string
noSmithyDocumentSerde
}
func (e *InvalidParameterValueException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidParameterValueException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidParameterValueException) ErrorCode() string { return "InvalidParameterValueException" }
func (e *InvalidParameterValueException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type MacAddressAlreadyInUseException struct {
Message *string
noSmithyDocumentSerde
}
func (e *MacAddressAlreadyInUseException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *MacAddressAlreadyInUseException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *MacAddressAlreadyInUseException) ErrorCode() string {
return "MacAddressAlreadyInUseException"
}
func (e *MacAddressAlreadyInUseException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type MaxDirectNetworkExceededException struct {
Message *string
noSmithyDocumentSerde
}
func (e *MaxDirectNetworkExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *MaxDirectNetworkExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *MaxDirectNetworkExceededException) ErrorCode() string {
return "MaxDirectNetworkExceededException"
}
func (e *MaxDirectNetworkExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type MissingParameterException struct {
Message *string
noSmithyDocumentSerde
}
func (e *MissingParameterException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *MissingParameterException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *MissingParameterException) ErrorCode() string { return "MissingParameterException" }
func (e *MissingParameterException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type NoCloudConnectionException struct {
Message *string
noSmithyDocumentSerde
}
func (e *NoCloudConnectionException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *NoCloudConnectionException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *NoCloudConnectionException) ErrorCode() string { return "NoCloudConnectionException" }
func (e *NoCloudConnectionException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type NoDirectNetworkSupportException struct {
Message *string
noSmithyDocumentSerde
}
func (e *NoDirectNetworkSupportException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *NoDirectNetworkSupportException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *NoDirectNetworkSupportException) ErrorCode() string {
return "NoDirectNetworkSupportException"
}
func (e *NoDirectNetworkSupportException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ResourceNotFoundException struct {
Message *string
noSmithyDocumentSerde
}
func (e *ResourceNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotFoundException) ErrorCode() string { return "ResourceNotFoundException" }
func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ServiceAlreadyStartedException struct {
Message *string
noSmithyDocumentSerde
}
func (e *ServiceAlreadyStartedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceAlreadyStartedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceAlreadyStartedException) ErrorCode() string { return "ServiceAlreadyStartedException" }
func (e *ServiceAlreadyStartedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type TimeServiceSettingPersistenceException struct {
Message *string
noSmithyDocumentSerde
}
func (e *TimeServiceSettingPersistenceException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TimeServiceSettingPersistenceException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TimeServiceSettingPersistenceException) ErrorCode() string {
return "TimeServiceSettingPersistenceException"
}
func (e *TimeServiceSettingPersistenceException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type TimeServiceUnavailableException struct {
Message *string
noSmithyDocumentSerde
}
func (e *TimeServiceUnavailableException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TimeServiceUnavailableException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TimeServiceUnavailableException) ErrorCode() string {
return "TimeServiceUnavailableException"
}
func (e *TimeServiceUnavailableException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type UnsupportedOperationException struct {
Message *string
noSmithyDocumentSerde
}
func (e *UnsupportedOperationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UnsupportedOperationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UnsupportedOperationException) ErrorCode() string { return "UnsupportedOperationException" }
func (e *UnsupportedOperationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 341 |
eks-anywhere | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
)
type AutoStartConfiguration struct {
AutoStartConfigurationArn *string
Enabled bool
IpAddressAssignment IpAddressAssignment
LaunchTemplateId *string
LaunchTemplateVersion *string
PhysicalConnectorType PhysicalConnectorType
StaticIpAddressConfiguration *StaticIpAddressConfiguration
noSmithyDocumentSerde
}
type AutoStartConfigurationDetails struct {
AutoStartConfiguration *AutoStartConfiguration
AutoStartDetails *AutoStartDetails
noSmithyDocumentSerde
}
type AutoStartDetails struct {
InstanceId *string
InterfaceId *string
State *string
StateMessage *string
noSmithyDocumentSerde
}
type AutoUpdateStrategy struct {
AutoCheck bool
AutoCheckFrequency *string
AutoDownload bool
AutoDownloadFrequency *string
AutoInstall bool
AutoInstallFrequency *string
AutoReboot bool
noSmithyDocumentSerde
}
type Capacity struct {
Available *int64
Name *string
Total *int64
Unit *string
Used *int64
noSmithyDocumentSerde
}
type CertificateAssociation struct {
// This member is required.
CertificateArn *string
noSmithyDocumentSerde
}
type CertificateSummary struct {
// This member is required.
CertificateArn *string
SubjectAlternativeNames []string
noSmithyDocumentSerde
}
type ClusterAssociation struct {
// This member is required.
ClusterId *string
// This member is required.
State ClusterAssociationState
ClusteredNetworkInterface *PhysicalNetworkInterface
noSmithyDocumentSerde
}
type Device struct {
ActiveNetworkInterface *NetworkInterface
ClusterAssociation *ClusterAssociation
DeviceId *string
NetworkReachability *NetworkReachability
PhysicalNetworkInterfaces []PhysicalNetworkInterface
Tags []Tag
UnlockStatus *UnlockStatus
noSmithyDocumentSerde
}
type DirectNetworkInterface struct {
// This member is required.
DirectNetworkInterfaceArn *string
// This member is required.
Driver DirectNetworkDriver
// This member is required.
MacAddress *string
// This member is required.
PhysicalNetworkInterfaceId *string
InstanceId *string
VlanId *int32
noSmithyDocumentSerde
}
type Endpoint struct {
// This member is required.
Host *string
// This member is required.
Port int32
// This member is required.
Protocol *string
CertificateAssociation *CertificateAssociation
noSmithyDocumentSerde
}
type NetworkInterface struct {
IpAddress *string
noSmithyDocumentSerde
}
type NetworkReachability struct {
// This member is required.
State NetworkReachabilityState
noSmithyDocumentSerde
}
type PhysicalNetworkInterface struct {
DefaultGateway *string
IpAddress *string
IpAddressAssignment IpAddressAssignment
MacAddress *string
Netmask *string
PhysicalConnectorType PhysicalConnectorType
PhysicalNetworkInterfaceId *string
noSmithyDocumentSerde
}
type ServiceConfiguration struct {
AllowedHosts []string
noSmithyDocumentSerde
}
type ServiceStatus struct {
State ServiceStatusState
noSmithyDocumentSerde
}
type ServiceStorage struct {
// This member is required.
FreeSpaceBytes int64
// This member is required.
TotalSpaceBytes int64
noSmithyDocumentSerde
}
type StaticIpAddressConfiguration struct {
// This member is required.
IpAddress *string
// This member is required.
Netmask *string
noSmithyDocumentSerde
}
type Tag struct {
Key *string
Value *string
noSmithyDocumentSerde
}
type TimeSourceStatus struct {
// This member is required.
Address *string
// This member is required.
State TimeSourceState
// This member is required.
Stratum int32
// This member is required.
Type TimeSourceType
noSmithyDocumentSerde
}
type UnlockStatus struct {
// This member is required.
State UnlockStatusState
noSmithyDocumentSerde
}
type VirtualNetworkInterface struct {
DefaultGateway *string
IpAddress *string
IpAddressAssignment IpAddressAssignment
MacAddress *string
Netmask *string
PhysicalNetworkInterfaceId *string
VirtualNetworkInterfaceArn *string
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 283 |
eks-anywhere | aws | Go | package api
import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
type AWSIamConfigOpt func(c *v1alpha1.AWSIamConfig)
func NewAWSIamConfig(name string, opts ...AWSIamConfigOpt) *v1alpha1.AWSIamConfig {
config := &v1alpha1.AWSIamConfig{
TypeMeta: metav1.TypeMeta{
APIVersion: v1alpha1.SchemeBuilder.GroupVersion.String(),
Kind: v1alpha1.AWSIamConfigKind,
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
Spec: v1alpha1.AWSIamConfigSpec{},
}
for _, opt := range opts {
opt(config)
}
return config
}
func WithAWSIamAWSRegion(awsRegion string) AWSIamConfigOpt {
return func(c *v1alpha1.AWSIamConfig) {
c.Spec.AWSRegion = awsRegion
}
}
func WithAWSIamBackendMode(backendMode string) AWSIamConfigOpt {
return func(c *v1alpha1.AWSIamConfig) {
c.Spec.BackendMode = append(c.Spec.BackendMode, backendMode)
}
}
func AddAWSIamRole(arn, username string, groups []string) *v1alpha1.MapRoles {
return &v1alpha1.MapRoles{
RoleARN: arn,
Username: username,
Groups: groups,
}
}
func WithAWSIamMapRoles(mapRoles *v1alpha1.MapRoles) AWSIamConfigOpt {
return func(c *v1alpha1.AWSIamConfig) {
c.Spec.MapRoles = append(c.Spec.MapRoles, *mapRoles)
}
}
func AddAWSIamUser(arn, username string, groups []string) *v1alpha1.MapUsers {
return &v1alpha1.MapUsers{
UserARN: arn,
Username: username,
Groups: groups,
}
}
func WithAWSIamMapUsers(mapUsers *v1alpha1.MapUsers) AWSIamConfigOpt {
return func(c *v1alpha1.AWSIamConfig) {
c.Spec.MapUsers = append(c.Spec.MapUsers, *mapUsers)
}
}
func WithAWSIamPartition(partition string) AWSIamConfigOpt {
return func(c *v1alpha1.AWSIamConfig) {
c.Spec.Partition = partition
}
}
| 73 |
eks-anywhere | aws | Go | package api
import (
"fmt"
"os"
"strings"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
)
type CloudStackConfig struct {
datacenterConfig *anywherev1.CloudStackDatacenterConfig
machineConfigs map[string]*anywherev1.CloudStackMachineConfig
}
type CloudStackFiller func(config CloudStackConfig)
// CloudStackToConfigFiller transforms a set of CloudStackFiller's in a single ClusterConfigFiller.
func CloudStackToConfigFiller(fillers ...CloudStackFiller) ClusterConfigFiller {
return func(c *cluster.Config) {
updateCloudStack(c, fillers...)
}
}
func updateCloudStack(config *cluster.Config, fillers ...CloudStackFiller) {
cc := CloudStackConfig{
datacenterConfig: config.CloudStackDatacenter,
machineConfigs: config.CloudStackMachineConfigs,
}
for _, f := range fillers {
f(cc)
}
}
func WithCloudStackComputeOfferingForAllMachines(value string) CloudStackFiller {
return func(config CloudStackConfig) {
for _, m := range config.machineConfigs {
m.Spec.ComputeOffering.Name = value
}
}
}
func WithCloudStackAz(az anywherev1.CloudStackAvailabilityZone) CloudStackFiller {
return func(config CloudStackConfig) {
config.datacenterConfig.Spec.AvailabilityZones = append(config.datacenterConfig.Spec.AvailabilityZones, az)
}
}
func RemoveCloudStackAzs() CloudStackFiller {
return func(config CloudStackConfig) {
config.datacenterConfig.Spec.AvailabilityZones = make([]anywherev1.CloudStackAvailabilityZone, 0)
}
}
func WithCloudStackAffinityGroupIds(value []string) CloudStackFiller {
return func(config CloudStackConfig) {
for _, m := range config.machineConfigs {
m.Spec.AffinityGroupIds = value
}
}
}
func WithUserCustomDetails(value map[string]string) CloudStackFiller {
return func(config CloudStackConfig) {
for _, m := range config.machineConfigs {
m.Spec.UserCustomDetails = value
}
}
}
func WithSymlinks(value map[string]string) CloudStackFiller {
return func(config CloudStackConfig) {
for _, m := range config.machineConfigs {
m.Spec.Symlinks = value
}
}
}
func WithCloudStackTemplateForAllMachines(value string) CloudStackFiller {
return func(config CloudStackConfig) {
for _, m := range config.machineConfigs {
m.Spec.Template.Name = value
}
}
}
func WithCloudStackConfigNamespace(ns string) CloudStackFiller {
return func(config CloudStackConfig) {
config.datacenterConfig.Namespace = ns
for _, m := range config.machineConfigs {
m.Namespace = ns
}
}
}
func WithCloudStackSSHAuthorizedKey(value string) CloudStackFiller {
return func(config CloudStackConfig) {
for _, m := range config.machineConfigs {
if len(m.Spec.Users) == 0 {
m.Spec.Users = []anywherev1.UserConfiguration{{Name: "capc"}}
}
m.Spec.Users[0].SshAuthorizedKeys = []string{value}
}
}
}
func WithCloudStackDomain(value string) CloudStackFiller {
return func(config CloudStackConfig) {
for _, az := range config.datacenterConfig.Spec.AvailabilityZones {
az.Domain = value
}
}
}
func WithCloudStackAccount(value string) CloudStackFiller {
return func(config CloudStackConfig) {
for _, az := range config.datacenterConfig.Spec.AvailabilityZones {
az.Account = value
}
}
}
// WithCloudStackCredentialsRef returns a CloudStackFiller that updates the edentialsRef of all availability zones.
func WithCloudStackCredentialsRef(value string) CloudStackFiller {
return func(config CloudStackConfig) {
zones := []anywherev1.CloudStackAvailabilityZone{}
for _, az := range config.datacenterConfig.Spec.AvailabilityZones {
az.CredentialsRef = value
zones = append(zones, az)
}
config.datacenterConfig.Spec.AvailabilityZones = zones
}
}
func WithCloudStackStringFromEnvVar(envVar string, opt func(string) CloudStackFiller) CloudStackFiller {
return opt(os.Getenv(envVar))
}
func WithCloudStackAzFromEnvVars(cloudstackAccountVar, cloudstackDomainVar, cloudstackZoneVar, cloudstackCredentialsVar, cloudstackNetworkVar, cloudstackManagementServerVar string, opt func(zone anywherev1.CloudStackAvailabilityZone) CloudStackFiller) CloudStackFiller {
az := anywherev1.CloudStackAvailabilityZone{
Name: strings.ToLower(fmt.Sprintf("az-%s", os.Getenv(cloudstackZoneVar))),
CredentialsRef: os.Getenv(cloudstackCredentialsVar),
Zone: anywherev1.CloudStackZone{
Name: os.Getenv(cloudstackZoneVar),
Network: anywherev1.CloudStackResourceIdentifier{
Name: os.Getenv(cloudstackNetworkVar),
},
},
Domain: os.Getenv(cloudstackDomainVar),
Account: os.Getenv(cloudstackAccountVar),
ManagementApiEndpoint: os.Getenv(cloudstackManagementServerVar),
}
return opt(az)
}
func WithCloudStackMachineConfig(name string, fillers ...CloudStackMachineConfigFiller) CloudStackFiller {
return func(config CloudStackConfig) {
m, ok := config.machineConfigs[name]
if !ok {
m = &anywherev1.CloudStackMachineConfig{
TypeMeta: metav1.TypeMeta{
Kind: anywherev1.CloudStackMachineConfigKind,
APIVersion: anywherev1.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
}
config.machineConfigs[name] = m
}
FillCloudStackMachineConfig(m, fillers...)
}
}
// WithCloudStackConfigNamespaceForAllMachinesAndDatacenter sets the namespace for all Machines and Datacenter objects.
func WithCloudStackConfigNamespaceForAllMachinesAndDatacenter(ns string) CloudStackFiller {
return func(config CloudStackConfig) {
config.datacenterConfig.Namespace = ns
for _, m := range config.machineConfigs {
m.Namespace = ns
}
}
}
| 190 |
eks-anywhere | aws | Go | package api
import (
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
type CloudStackMachineConfigFiller func(m *anywherev1.CloudStackMachineConfig)
func FillCloudStackMachineConfig(m *anywherev1.CloudStackMachineConfig, fillers ...CloudStackMachineConfigFiller) {
for _, f := range fillers {
f(m)
}
}
func WithCloudStackComputeOffering(value string) CloudStackMachineConfigFiller {
return func(m *anywherev1.CloudStackMachineConfig) {
m.Spec.ComputeOffering.Name = value
}
}
func WithCloudStackSSHKey(value string) CloudStackMachineConfigFiller {
return func(m *anywherev1.CloudStackMachineConfig) {
setCloudStackSSHKeyForFirstUser(m, value)
}
}
func setCloudStackSSHKeyForFirstUser(m *anywherev1.CloudStackMachineConfig, key string) {
if len(m.Spec.Users) == 0 {
m.Spec.Users = []anywherev1.UserConfiguration{{
Name: v1alpha1.DefaultCloudStackUser,
}}
}
m.Spec.Users[0].SshAuthorizedKeys = []string{key}
}
| 37 |
eks-anywhere | aws | Go | package api
import (
_ "embed"
"testing"
. "github.com/onsi/gomega"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
)
const clusterConfigFile = "testdata/cloudstack-config.yaml"
func TestCloudStackMachineConfigFillers(t *testing.T) {
testOffering := "test-compute-offering"
testTemplate := "test-template"
testSshKey := "test-ssh-key"
g := NewWithT(t)
config, err := cluster.ParseConfigFromFile(clusterConfigFile)
if err != nil {
g.Fail("failed to parse cluster from file")
}
cloudStackConfig := CloudStackConfig{
machineConfigs: config.CloudStackMachineConfigs,
}
WithCloudStackComputeOfferingForAllMachines(testOffering)(cloudStackConfig)
WithCloudStackTemplateForAllMachines(testTemplate)(cloudStackConfig)
WithCloudStackSSHAuthorizedKey(testSshKey)(cloudStackConfig)
for _, machineConfig := range cloudStackConfig.machineConfigs {
g.Expect(machineConfig.Spec.ComputeOffering.Name).To(Equal(testOffering))
g.Expect(machineConfig.Spec.Template.Name).To(Equal(testTemplate))
g.Expect(machineConfig.Spec.Users[0].SshAuthorizedKeys[0]).To(Equal(testSshKey))
}
}
func TestCloudStackDatacenterConfigFillers(t *testing.T) {
testAz := anywherev1.CloudStackAvailabilityZone{
Name: "testAz",
CredentialsRef: "testCreds",
Zone: anywherev1.CloudStackZone{
Name: "zone1",
Network: anywherev1.CloudStackResourceIdentifier{
Name: "SharedNet1",
},
},
Domain: "testDomain",
Account: "testAccount",
ManagementApiEndpoint: "testApiEndpoint",
}
g := NewWithT(t)
config, err := cluster.ParseConfigFromFile(clusterConfigFile)
if err != nil {
g.Fail("failed to parse cluster from file")
}
cloudStackConfig := CloudStackConfig{
datacenterConfig: config.CloudStackDatacenter,
}
RemoveCloudStackAzs()(cloudStackConfig)
WithCloudStackAz(testAz)(cloudStackConfig)
g.Expect(len(cloudStackConfig.datacenterConfig.Spec.AvailabilityZones)).To(Equal(1))
g.Expect(cloudStackConfig.datacenterConfig.Spec.AvailabilityZones[0]).To(Equal(testAz))
testAz2 := *testAz.DeepCopy()
testAz2.Name = "testAz2"
WithCloudStackAz(testAz2)(cloudStackConfig)
g.Expect(len(cloudStackConfig.datacenterConfig.Spec.AvailabilityZones)).To(Equal(2))
g.Expect(cloudStackConfig.datacenterConfig.Spec.AvailabilityZones[0]).To(Equal(testAz))
g.Expect(cloudStackConfig.datacenterConfig.Spec.AvailabilityZones[1]).To(Equal(testAz2))
RemoveCloudStackAzs()(cloudStackConfig)
g.Expect(len(cloudStackConfig.datacenterConfig.Spec.AvailabilityZones)).To(Equal(0))
}
func TestCloudStackAzFromEnvVars(t *testing.T) {
testAz := anywherev1.CloudStackAvailabilityZone{
Name: "az-zone1",
CredentialsRef: "global",
Zone: anywherev1.CloudStackZone{
Name: "zone1",
Network: anywherev1.CloudStackResourceIdentifier{
Name: "SharedNet1",
},
},
Domain: "testDomain",
Account: "testAccount",
ManagementApiEndpoint: "testApiEndpoint",
}
accountVar := "CLOUDSTACK_ACCOUNT"
domainVar := "CLOUDSTACK_DOMAIN"
zoneVar := "CLOUDSTACK_ZONE"
networkVar := "CLOUDSTACK_NETWORK"
endpointVar := "CLOUDSTACK_ENDPOINT"
credentialsVar := "CLOUDSTACK_CREDENTIALS"
t.Setenv(accountVar, testAz.Account)
t.Setenv(domainVar, testAz.Domain)
t.Setenv(zoneVar, testAz.Zone.Name)
t.Setenv(networkVar, testAz.Zone.Network.Name)
t.Setenv(endpointVar, testAz.ManagementApiEndpoint)
t.Setenv(credentialsVar, testAz.CredentialsRef)
g := NewWithT(t)
config, err := cluster.ParseConfigFromFile(clusterConfigFile)
if err != nil {
g.Fail("failed to parse cluster from file")
}
cloudStackConfig := CloudStackConfig{
datacenterConfig: config.CloudStackDatacenter,
}
RemoveCloudStackAzs()(cloudStackConfig)
WithCloudStackAzFromEnvVars(accountVar, domainVar, zoneVar, credentialsVar, networkVar, endpointVar, WithCloudStackAz)(cloudStackConfig)
g.Expect(len(cloudStackConfig.datacenterConfig.Spec.AvailabilityZones)).To(Equal(1))
g.Expect(cloudStackConfig.datacenterConfig.Spec.AvailabilityZones[0]).To(Equal(testAz))
}
| 119 |
eks-anywhere | aws | Go | package api
import (
"fmt"
"strings"
corev1 "k8s.io/api/core/v1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
"github.com/aws/eks-anywhere/pkg/logger"
"github.com/aws/eks-anywhere/pkg/providers"
"github.com/aws/eks-anywhere/pkg/utils/ptr"
)
type ClusterFiller func(c *anywherev1.Cluster)
// ClusterToConfigFiller updates the Cluster in the cluster.Config by applying all the fillers.
func ClusterToConfigFiller(fillers ...ClusterFiller) ClusterConfigFiller {
return func(c *cluster.Config) {
for _, f := range fillers {
f(c.Cluster)
}
}
}
// JoinClusterConfigFillers creates one single ClusterConfigFiller from a collection of fillers.
func JoinClusterConfigFillers(fillers ...ClusterConfigFiller) ClusterConfigFiller {
return func(c *cluster.Config) {
for _, f := range fillers {
f(c)
}
}
}
func WithKubernetesVersion(v anywherev1.KubernetesVersion) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.KubernetesVersion = v
}
}
// WithBundlesRef sets BundlesRef with the provided name to use.
func WithBundlesRef(name string, namespace string, apiVersion string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.BundlesRef = &anywherev1.BundlesRef{Name: name, Namespace: namespace, APIVersion: apiVersion}
}
}
func WithCiliumPolicyEnforcementMode(mode anywherev1.CiliumPolicyEnforcementMode) ClusterFiller {
return func(c *anywherev1.Cluster) {
if c.Spec.ClusterNetwork.CNIConfig == nil {
c.Spec.ClusterNetwork.CNIConfig = &anywherev1.CNIConfig{Cilium: &anywherev1.CiliumConfig{}}
}
c.Spec.ClusterNetwork.CNIConfig.Cilium.PolicyEnforcementMode = mode
}
}
// WithCiliumEgressMasqueradeInterfaces sets the egressMasqueradeInterfaces with the provided interface option to use.
func WithCiliumEgressMasqueradeInterfaces(interfaceName string) ClusterFiller {
return func(c *anywherev1.Cluster) {
if c.Spec.ClusterNetwork.CNIConfig == nil {
c.Spec.ClusterNetwork.CNIConfig = &anywherev1.CNIConfig{Cilium: &anywherev1.CiliumConfig{}}
}
c.Spec.ClusterNetwork.CNIConfig.Cilium.EgressMasqueradeInterfaces = interfaceName
}
}
// WithCiliumSkipUpgrade enables skip upgrade for EKSA Cilium installations.
func WithCiliumSkipUpgrade() ClusterFiller {
return func(c *anywherev1.Cluster) {
network := c.Spec.ClusterNetwork
if network.CNIConfig != nil && network.CNIConfig.Cilium != nil {
fmt.Println("Enable ciliun skip upgrade")
network.CNIConfig.Cilium.SkipUpgrade = ptr.Bool(true)
}
}
}
func WithClusterNamespace(ns string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Namespace = ns
}
}
func WithControlPlaneCount(r int) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.ControlPlaneConfiguration.Count = r
}
}
func WithControlPlaneEndpointIP(value string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.ControlPlaneConfiguration.Endpoint.Host = value
}
}
func WithControlPlaneTaints(taints []corev1.Taint) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.ControlPlaneConfiguration.Taints = taints
}
}
func WithControlPlaneLabel(key string, val string) ClusterFiller {
return func(c *anywherev1.Cluster) {
if c.Spec.ControlPlaneConfiguration.Labels == nil {
c.Spec.ControlPlaneConfiguration.Labels = map[string]string{}
}
c.Spec.ControlPlaneConfiguration.Labels[key] = val
}
}
// WithPodCidr sets an explicit pod CIDR, overriding the provider's default.
func WithPodCidr(podCidr string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.ClusterNetwork.Pods.CidrBlocks = strings.Split(podCidr, ",")
}
}
func WithServiceCidr(svcCidr string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.ClusterNetwork.Services.CidrBlocks = []string{svcCidr}
}
}
func WithWorkerNodeCount(r int) ClusterFiller {
return func(c *anywherev1.Cluster) {
if len(c.Spec.WorkerNodeGroupConfigurations) == 0 {
c.Spec.WorkerNodeGroupConfigurations = []anywherev1.WorkerNodeGroupConfiguration{{Count: ptr.Int(0)}}
}
c.Spec.WorkerNodeGroupConfigurations[0].Count = &r
}
}
// WithWorkerNodeAutoScalingConfig adds an autoscaling configuration with a given min and max count.
func WithWorkerNodeAutoScalingConfig(min int, max int) ClusterFiller {
return func(c *anywherev1.Cluster) {
if len(c.Spec.WorkerNodeGroupConfigurations) == 0 {
c.Spec.WorkerNodeGroupConfigurations = []anywherev1.WorkerNodeGroupConfiguration{{Count: ptr.Int(min)}}
}
c.Spec.WorkerNodeGroupConfigurations[0].AutoScalingConfiguration = &anywherev1.AutoScalingConfiguration{
MinCount: min,
MaxCount: max,
}
}
}
func WithOIDCIdentityProviderRef(name string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.IdentityProviderRefs = append(c.Spec.IdentityProviderRefs,
anywherev1.Ref{Name: name, Kind: anywherev1.OIDCConfigKind})
}
}
func WithGitOpsRef(name, kind string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.GitOpsRef = &anywherev1.Ref{Name: name, Kind: kind}
}
}
func WithExternalEtcdTopology(count int) ClusterFiller {
return func(c *anywherev1.Cluster) {
if c.Spec.ExternalEtcdConfiguration == nil {
c.Spec.ExternalEtcdConfiguration = &anywherev1.ExternalEtcdConfiguration{}
}
c.Spec.ExternalEtcdConfiguration.Count = count
}
}
func WithEtcdCountIfExternal(count int) ClusterFiller {
return func(c *anywherev1.Cluster) {
if c.Spec.ExternalEtcdConfiguration != nil {
c.Spec.ExternalEtcdConfiguration.Count = count
}
}
}
func WithExternalEtcdMachineRef(kind string) ClusterFiller {
return func(c *anywherev1.Cluster) {
if c.Spec.ExternalEtcdConfiguration == nil {
c.Spec.ExternalEtcdConfiguration = &anywherev1.ExternalEtcdConfiguration{}
c.Spec.ExternalEtcdConfiguration.Count = 1
}
if c.Spec.ExternalEtcdConfiguration.MachineGroupRef == nil {
c.Spec.ExternalEtcdConfiguration.MachineGroupRef = &anywherev1.Ref{}
}
c.Spec.ExternalEtcdConfiguration.MachineGroupRef.Kind = kind
c.Spec.ExternalEtcdConfiguration.MachineGroupRef.Name = providers.GetEtcdNodeName(c.Name)
}
}
func WithStackedEtcdTopology() ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.ExternalEtcdConfiguration = nil
}
}
func WithProxyConfig(httpProxy, httpsProxy string, noProxy []string) ClusterFiller {
return func(c *anywherev1.Cluster) {
if c.Spec.ProxyConfiguration == nil {
c.Spec.ProxyConfiguration = &anywherev1.ProxyConfiguration{}
}
c.Spec.ProxyConfiguration.HttpProxy = httpProxy
c.Spec.ProxyConfiguration.HttpsProxy = httpProxy
c.Spec.ProxyConfiguration.NoProxy = noProxy
}
}
// WithRegistryMirror adds a registry mirror configuration.
func WithRegistryMirror(endpoint, port string, caCert string, authenticate bool, insecureSkipVerify bool) ClusterFiller {
return func(c *anywherev1.Cluster) {
if c.Spec.RegistryMirrorConfiguration == nil {
c.Spec.RegistryMirrorConfiguration = &anywherev1.RegistryMirrorConfiguration{}
}
c.Spec.RegistryMirrorConfiguration.Endpoint = endpoint
c.Spec.RegistryMirrorConfiguration.Port = port
c.Spec.RegistryMirrorConfiguration.CACertContent = caCert
c.Spec.RegistryMirrorConfiguration.Authenticate = authenticate
c.Spec.RegistryMirrorConfiguration.InsecureSkipVerify = insecureSkipVerify
}
}
func WithManagementCluster(name string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.ManagementCluster.Name = name
}
}
func WithAWSIamIdentityProviderRef(name string) ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.IdentityProviderRefs = append(c.Spec.IdentityProviderRefs,
anywherev1.Ref{Name: name, Kind: anywherev1.AWSIamConfigKind})
}
}
func RemoveAllWorkerNodeGroups() ClusterFiller {
return func(c *anywherev1.Cluster) {
c.Spec.WorkerNodeGroupConfigurations = make([]anywherev1.WorkerNodeGroupConfiguration, 0)
}
}
func RemoveWorkerNodeGroup(name string) ClusterFiller {
logger.Info("removing", "name", name)
return func(c *anywherev1.Cluster) {
logger.Info("before deleting", "w", c.Spec.WorkerNodeGroupConfigurations)
for i, w := range c.Spec.WorkerNodeGroupConfigurations {
if w.Name == name {
copy(c.Spec.WorkerNodeGroupConfigurations[i:], c.Spec.WorkerNodeGroupConfigurations[i+1:])
c.Spec.WorkerNodeGroupConfigurations[len(c.Spec.WorkerNodeGroupConfigurations)-1] = anywherev1.WorkerNodeGroupConfiguration{}
c.Spec.WorkerNodeGroupConfigurations = c.Spec.WorkerNodeGroupConfigurations[:len(c.Spec.WorkerNodeGroupConfigurations)-1]
logger.Info("after deleting", "w", c.Spec.WorkerNodeGroupConfigurations)
return
}
}
}
}
func WithWorkerNodeGroup(name string, fillers ...WorkerNodeGroupFiller) ClusterFiller {
return func(c *anywherev1.Cluster) {
var nodeGroup *anywherev1.WorkerNodeGroupConfiguration
position := -1
for i, w := range c.Spec.WorkerNodeGroupConfigurations {
if w.Name == name {
logger.Info("Updating worker node group", "name", name)
nodeGroup = &w
position = i
break
}
}
if nodeGroup == nil {
logger.Info("Adding worker node group", "name", name)
nodeGroup = &anywherev1.WorkerNodeGroupConfiguration{Name: name}
c.Spec.WorkerNodeGroupConfigurations = append(c.Spec.WorkerNodeGroupConfigurations, *nodeGroup)
position = len(c.Spec.WorkerNodeGroupConfigurations) - 1
}
FillWorkerNodeGroup(nodeGroup, fillers...)
c.Spec.WorkerNodeGroupConfigurations[position] = *nodeGroup
}
}
| 282 |
eks-anywhere | aws | Go | package api_test
import (
"testing"
. "github.com/onsi/gomega"
"github.com/aws/eks-anywhere/internal/pkg/api"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/utils/ptr"
)
func TestWithWorkerNodeCount(t *testing.T) {
tests := []struct {
name string
cluster *anywherev1.Cluster
want []anywherev1.WorkerNodeGroupConfiguration
}{
{
name: "with worker node config empty",
cluster: &anywherev1.Cluster{
Spec: anywherev1.ClusterSpec{},
},
want: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "",
Count: ptr.Int(5),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
{
name: "with worker node config greater than one",
cluster: &anywherev1.Cluster{
Spec: anywherev1.ClusterSpec{
WorkerNodeGroupConfigurations: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "md-0",
Count: ptr.Int(1),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
{
Name: "md-1",
Count: ptr.Int(1),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
},
want: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "md-0",
Count: ptr.Int(5),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
{
Name: "md-1",
Count: ptr.Int(1),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
{
name: "with empty worker node config",
cluster: &anywherev1.Cluster{
Spec: anywherev1.ClusterSpec{},
},
want: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "",
Count: ptr.Int(5),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
api.WithWorkerNodeCount(5)(tt.cluster)
g := NewWithT(t)
g.Expect(tt.cluster.Spec.WorkerNodeGroupConfigurations).To(Equal(tt.want))
})
}
}
func TestWithWorkerNodeAutoScalingConfig(t *testing.T) {
expectedAutoScalingConfiguration := &anywherev1.AutoScalingConfiguration{
MinCount: 1,
MaxCount: 5,
}
tests := []struct {
name string
cluster *anywherev1.Cluster
want []anywherev1.WorkerNodeGroupConfiguration
}{
{
name: "with worker node config without autoscaling",
cluster: &anywherev1.Cluster{
Spec: anywherev1.ClusterSpec{
WorkerNodeGroupConfigurations: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "md-0",
Count: ptr.Int(2),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
},
want: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "md-0",
Count: ptr.Int(2),
AutoScalingConfiguration: expectedAutoScalingConfiguration,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
{
name: "with worker node config empty",
cluster: &anywherev1.Cluster{
Spec: anywherev1.ClusterSpec{},
},
want: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "",
Count: ptr.Int(1),
AutoScalingConfiguration: expectedAutoScalingConfiguration,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
{
name: "with worker node config greater than one",
cluster: &anywherev1.Cluster{
Spec: anywherev1.ClusterSpec{
WorkerNodeGroupConfigurations: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "md-0",
Count: ptr.Int(1),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
{
Name: "md-1",
Count: ptr.Int(1),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
},
want: []anywherev1.WorkerNodeGroupConfiguration{
{
Name: "md-0",
Count: ptr.Int(1),
AutoScalingConfiguration: expectedAutoScalingConfiguration,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
{
Name: "md-1",
Count: ptr.Int(1),
AutoScalingConfiguration: nil,
MachineGroupRef: nil,
Taints: nil,
Labels: nil,
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
api.WithWorkerNodeAutoScalingConfig(1, 5)(tt.cluster)
g := NewWithT(t)
g.Expect(tt.cluster.Spec.WorkerNodeGroupConfigurations).To(Equal(tt.want))
})
}
}
func TestWithPodCidr(t *testing.T) {
cluster := &anywherev1.Cluster{
Spec: anywherev1.ClusterSpec{
ClusterNetwork: anywherev1.ClusterNetwork{
Pods: anywherev1.Pods{
CidrBlocks: []string{"192.168.0.0/16"},
},
},
},
}
t.Run("with a single CIDR block", func(t *testing.T) {
api.WithPodCidr("10.0.0.0/20")(cluster)
g := NewWithT(t)
g.Expect(cluster.Spec.ClusterNetwork.Pods.CidrBlocks).To(Equal([]string{"10.0.0.0/20"}))
})
t.Run("with a multiple CIDR blocks", func(t *testing.T) {
api.WithPodCidr("10.0.0.0/16,172.16.42.0/20")(cluster)
g := NewWithT(t)
g.Expect(cluster.Spec.ClusterNetwork.Pods.CidrBlocks).To(Equal([]string{"10.0.0.0/16", "172.16.42.0/20"}))
})
}
| 234 |
eks-anywhere | aws | Go | package api
import "github.com/aws/eks-anywhere/pkg/cluster"
// ClusterConfigFiller updates a cluster.Config.
type ClusterConfigFiller func(*cluster.Config)
// UpdateClusterConfig updates the given cluster.Config by applying the fillers.
func UpdateClusterConfig(config *cluster.Config, fillers ...ClusterConfigFiller) {
for _, f := range fillers {
f(config)
}
}
| 14 |
eks-anywhere | aws | Go | package api
import (
"os"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
type FluxConfigOpt func(o *v1alpha1.FluxConfig)
func NewFluxConfig(name string, opts ...FluxConfigOpt) *v1alpha1.FluxConfig {
config := &v1alpha1.FluxConfig{
TypeMeta: metav1.TypeMeta{
APIVersion: v1alpha1.SchemeBuilder.GroupVersion.String(),
Kind: v1alpha1.FluxConfigKind,
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
Spec: v1alpha1.FluxConfigSpec{},
}
for _, opt := range opts {
opt(config)
}
return config
}
func WithFluxConfigName(n string) FluxConfigOpt {
return func(c *v1alpha1.FluxConfig) {
c.Name = n
}
}
func WithFluxConfigNamespace(ns string) FluxConfigOpt {
return func(c *v1alpha1.FluxConfig) {
c.Namespace = ns
}
}
func WithBranch(branch string) FluxConfigOpt {
return func(c *v1alpha1.FluxConfig) {
c.Spec.Branch = branch
}
}
func WithClusterConfigPath(configPath string) FluxConfigOpt {
return func(c *v1alpha1.FluxConfig) {
c.Spec.ClusterConfigPath = configPath
}
}
func WithSystemNamespace(namespace string) FluxConfigOpt {
return func(c *v1alpha1.FluxConfig) {
c.Spec.SystemNamespace = namespace
}
}
func WithStringFromEnvVarFluxConfig(envVar string, opt func(string) FluxConfigOpt) FluxConfigOpt {
return opt(os.Getenv(envVar))
}
type GitProviderOpt func(o *v1alpha1.GitProviderConfig)
func WithGenericGitProvider(opts ...GitProviderOpt) FluxConfigOpt {
return func(c *v1alpha1.FluxConfig) {
g := &v1alpha1.GitProviderConfig{}
for _, opt := range opts {
opt(g)
}
c.Spec.Git = g
}
}
func WithGitRepositoryUrl(url string) GitProviderOpt {
return func(c *v1alpha1.GitProviderConfig) {
c.RepositoryUrl = url
}
}
func WithStringFromEnvVarGenericGitProviderConfig(envVar string, opt func(string) GitProviderOpt) GitProviderOpt {
return opt(os.Getenv(envVar))
}
type GithubProviderOpt func(o *v1alpha1.GithubProviderConfig)
func WithGithubProvider(opts ...GithubProviderOpt) FluxConfigOpt {
return func(c *v1alpha1.FluxConfig) {
g := &v1alpha1.GithubProviderConfig{}
for _, opt := range opts {
opt(g)
}
c.Spec.Github = g
}
}
func WithGithubOwner(owner string) GithubProviderOpt {
return func(c *v1alpha1.GithubProviderConfig) {
c.Owner = owner
}
}
func WithGithubRepository(repository string) GithubProviderOpt {
return func(c *v1alpha1.GithubProviderConfig) {
c.Repository = repository
}
}
func WithPersonalGithubRepository(personal bool) GithubProviderOpt {
return func(c *v1alpha1.GithubProviderConfig) {
c.Personal = personal
}
}
func WithStringFromEnvVarGithubProviderConfig(envVar string, opt func(string) GithubProviderOpt) GithubProviderOpt {
return opt(os.Getenv(envVar))
}
| 119 |
eks-anywhere | aws | Go | package api
import (
"os"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
type GitOpsConfigOpt func(o *v1alpha1.GitOpsConfig)
func NewGitOpsConfig(name string, opts ...GitOpsConfigOpt) *v1alpha1.GitOpsConfig {
config := &v1alpha1.GitOpsConfig{
TypeMeta: metav1.TypeMeta{
APIVersion: v1alpha1.SchemeBuilder.GroupVersion.String(),
Kind: v1alpha1.GitOpsConfigKind,
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
Spec: v1alpha1.GitOpsConfigSpec{},
}
for _, opt := range opts {
opt(config)
}
return config
}
func WithGitOpsNamespace(ns string) GitOpsConfigOpt {
return func(c *v1alpha1.GitOpsConfig) {
c.Namespace = ns
}
}
func WithFluxOwner(username string) GitOpsConfigOpt {
return func(c *v1alpha1.GitOpsConfig) {
c.Spec.Flux.Github.Owner = username
}
}
func WithFluxRepository(repository string) GitOpsConfigOpt {
return func(c *v1alpha1.GitOpsConfig) {
c.Spec.Flux.Github.Repository = repository
}
}
func WithFluxConfigurationPath(configPath string) GitOpsConfigOpt {
return func(c *v1alpha1.GitOpsConfig) {
c.Spec.Flux.Github.ClusterConfigPath = configPath
}
}
func WithFluxNamespace(namespace string) GitOpsConfigOpt {
return func(c *v1alpha1.GitOpsConfig) {
c.Spec.Flux.Github.FluxSystemNamespace = namespace
}
}
func WithFluxBranch(branch string) GitOpsConfigOpt {
return func(c *v1alpha1.GitOpsConfig) {
c.Spec.Flux.Github.Branch = branch
}
}
func WithPersonalFluxRepository(personal bool) GitOpsConfigOpt {
return func(c *v1alpha1.GitOpsConfig) {
c.Spec.Flux.Github.Personal = personal
}
}
func WithStringFromEnvVarGitOpsConfig(envVar string, opt func(string) GitOpsConfigOpt) GitOpsConfigOpt {
return opt(os.Getenv(envVar))
}
| 75 |
eks-anywhere | aws | Go | package api
import (
"fmt"
"io"
"os"
"path/filepath"
"github.com/gocarina/gocsv"
"github.com/aws/eks-anywhere/pkg/providers/tinkerbell/hardware"
)
const (
HardwareVendorDell = "dell"
HardwareVendorHP = "hp"
HardwareVendorSuperMicro = "supermicro"
HardwareVendorUnspecified = "unspecified"
HardwareLabelTypeKeyName = "type"
ControlPlane = "control-plane"
Worker = "worker"
ExternalEtcd = "etcd"
)
// Alias for backwards compatibility.
type Hardware = hardware.Machine
func NewHardwareSlice(r io.Reader) ([]*Hardware, error) {
hardware := []*Hardware{}
if err := gocsv.Unmarshal(r, &hardware); err != nil {
return nil, fmt.Errorf("failed to create hardware slice from reader: %v", err)
}
return hardware, nil
}
func NewHardwareSliceFromFile(file string) ([]*Hardware, error) {
hardwareFile, err := os.OpenFile(file, os.O_RDONLY, os.ModePerm)
if err != nil {
return nil, fmt.Errorf("failed to create hardware slice from hardware file: %v", err)
}
return NewHardwareSlice(hardwareFile)
}
func NewHardwareMapFromFile(file string) (map[string]*Hardware, error) {
slice, err := NewHardwareSliceFromFile(file)
if err != nil {
return nil, fmt.Errorf("failed to create hardware map from hardware file: %v", err)
}
return HardwareSliceToMap(slice), nil
}
// converts a hardware slice to a map. The first instance of the slice is used in case slice contains duplicates.
func HardwareSliceToMap(slice []*Hardware) map[string]*Hardware {
hardwareMap := make(map[string]*Hardware)
for _, h := range slice {
if _, exists := hardwareMap[h.MACAddress]; !exists {
hardwareMap[h.MACAddress] = h
}
}
return hardwareMap
}
func WriteHardwareSliceToCSV(hardware []*Hardware, csvFile string) error {
csvdir := filepath.Dir(csvFile)
err := os.MkdirAll(csvdir, 0o755)
if err != nil {
return fmt.Errorf("failed to create hardware csv file from slice: %v", err)
}
hardwareFile, err := os.OpenFile(csvFile, os.O_RDWR|os.O_CREATE, os.ModePerm)
if err != nil {
return fmt.Errorf("failed to create hardware csv file from slice: %v", err)
}
defer hardwareFile.Close()
if err := gocsv.MarshalFile(&hardware, hardwareFile); err != nil {
return fmt.Errorf("failed to create hardware csv file from slice: %v", err)
}
return nil
}
func HardwareMapToSlice(hardware map[string]*Hardware) []*Hardware {
harwareSlice := []*Hardware{}
for _, value := range hardware {
harwareSlice = append(harwareSlice, value)
}
return harwareSlice
}
func WriteHardwareMapToCSV(hardware map[string]*Hardware, csvFile string) error {
slice := HardwareMapToSlice(hardware)
return WriteHardwareSliceToCSV(slice, csvFile)
}
func SplitHardware(slice []*Hardware, chunkSize int) [][]*Hardware {
var chunks [][]*Hardware
for i := 0; i < len(slice); i += chunkSize {
end := i + chunkSize
// check slice capacity
if end > len(slice) {
end = len(slice)
finalChunk := append(chunks[len(chunks)-1], slice[i:end]...)
chunks[len(chunks)-1] = finalChunk
} else {
chunks = append(chunks, slice[i:end])
}
}
return chunks
}
| 118 |
eks-anywhere | aws | Go | package api
import (
corev1 "k8s.io/api/core/v1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
type WorkerNodeGroupFiller func(w *anywherev1.WorkerNodeGroupConfiguration)
func FillWorkerNodeGroup(w *anywherev1.WorkerNodeGroupConfiguration, fillers ...WorkerNodeGroupFiller) {
for _, f := range fillers {
f(w)
}
}
func WithTaint(taint corev1.Taint) WorkerNodeGroupFiller {
return func(w *anywherev1.WorkerNodeGroupConfiguration) {
w.Taints = append(w.Taints, taint)
}
}
func WithNoTaints() WorkerNodeGroupFiller {
return func(w *anywherev1.WorkerNodeGroupConfiguration) {
w.Taints = nil
}
}
func WithLabel(key, value string) WorkerNodeGroupFiller {
return func(w *anywherev1.WorkerNodeGroupConfiguration) {
if w.Labels == nil {
w.Labels = map[string]string{}
}
w.Labels[key] = value
}
}
func WithCount(count int) WorkerNodeGroupFiller {
return func(w *anywherev1.WorkerNodeGroupConfiguration) {
w.Count = &count
}
}
func WithMachineGroupRef(name, kind string) WorkerNodeGroupFiller {
return func(w *anywherev1.WorkerNodeGroupConfiguration) {
w.MachineGroupRef = &anywherev1.Ref{
Name: name,
Kind: kind,
}
}
}
| 52 |
eks-anywhere | aws | Go | package api
import (
"encoding/base64"
"os"
"strconv"
"k8s.io/apimachinery/pkg/api/resource"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
"github.com/aws/eks-anywhere/pkg/logger"
)
// NutanixConfig is a wrapper for the Nutanix provider spec.
type NutanixConfig struct {
datacenterConfig *anywherev1.NutanixDatacenterConfig
machineConfigs map[string]*anywherev1.NutanixMachineConfig
}
type NutanixFiller func(config *NutanixConfig)
// NutanixToConfigFiller transforms a set of NutanixFiller's in a single ClusterConfigFiller.
func NutanixToConfigFiller(fillers ...NutanixFiller) ClusterConfigFiller {
return func(c *cluster.Config) {
updateNutanix(c, fillers...)
}
}
func updateNutanix(config *cluster.Config, fillers ...NutanixFiller) {
nc := &NutanixConfig{
datacenterConfig: config.NutanixDatacenter,
machineConfigs: config.NutanixMachineConfigs,
}
for _, f := range fillers {
f(nc)
}
}
// WithNutanixStringFromEnvVar returns a NutanixFiller that sets the given string value to the given environment variable.
func WithNutanixStringFromEnvVar(envVar string, opt func(string) NutanixFiller) NutanixFiller {
return opt(os.Getenv(envVar))
}
// WithNutanixIntFromEnvVar returns a NutanixFiller that sets the given integer value to the given environment variable.
func WithNutanixIntFromEnvVar(envVar string, opt func(int) NutanixFiller) NutanixFiller {
intVar, _ := strconv.Atoi(os.Getenv(envVar))
return opt(intVar)
}
// WithNutanixInt32FromEnvVar returns a NutanixFiller that sets the given int32 value to the given environment variable.
func WithNutanixInt32FromEnvVar(envVar string, opt func(int32) NutanixFiller) NutanixFiller {
intVar, _ := strconv.Atoi(os.Getenv(envVar))
return opt(int32(intVar))
}
// WithNutanixBoolFromEnvVar returns a NutanixFiller that sets the given int32 value to the given environment variable.
func WithNutanixBoolFromEnvVar(envVar string, opt func(bool) NutanixFiller) NutanixFiller {
return opt(os.Getenv(envVar) == "true")
}
// WithNutanixEndpoint returns a NutanixFiller that sets the endpoint for the Nutanix provider.
func WithNutanixEndpoint(value string) NutanixFiller {
return func(config *NutanixConfig) {
config.datacenterConfig.Spec.Endpoint = value
}
}
// WithNutanixPort returns a NutanixFiller that sets the port for the Nutanix provider.
func WithNutanixPort(value int) NutanixFiller {
return func(config *NutanixConfig) {
config.datacenterConfig.Spec.Port = value
}
}
// WithNutanixAdditionalTrustBundle returns a NutanixFiller that sets the additional trust bundle for the Nutanix provider.
func WithNutanixAdditionalTrustBundle(value string) NutanixFiller {
return func(config *NutanixConfig) {
certificate, err := base64.StdEncoding.DecodeString(value)
if err != nil {
logger.Info("Warning: Failed to decode AdditionalTrustBundle. AdditionalTrustBundle won't be added")
} else {
config.datacenterConfig.Spec.AdditionalTrustBundle = string(certificate)
}
}
}
// WithNutanixInsecure returns a NutanixFiller that sets the insecure for the Nutanix provider.
func WithNutanixInsecure(value bool) NutanixFiller {
return func(config *NutanixConfig) {
config.datacenterConfig.Spec.Insecure = value
}
}
// WithNutanixMachineMemorySize returns a NutanixFiller that sets the memory size for the Nutanix machine.
func WithNutanixMachineMemorySize(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.MemorySize = resource.MustParse(value)
}
}
}
// WithNutanixMachineSystemDiskSize returns a NutanixFiller that sets the system disk size for the Nutanix machine.
func WithNutanixMachineSystemDiskSize(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.SystemDiskSize = resource.MustParse(value)
}
}
}
// WithNutanixMachineVCPUsPerSocket returns a NutanixFiller that sets the vCPUs per socket for the Nutanix machine.
func WithNutanixMachineVCPUsPerSocket(value int32) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.VCPUsPerSocket = value
}
}
}
// WithNutanixMachineVCPUSocket returns a NutanixFiller that sets the vCPU sockets for the Nutanix machine.
func WithNutanixMachineVCPUSocket(value int32) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.VCPUSockets = value
}
}
}
// WithNutanixMachineTemplateImageName returns a NutanixFiller that sets the image name for the Nutanix machine template.
func WithNutanixMachineTemplateImageName(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.Image = anywherev1.NutanixResourceIdentifier{Type: anywherev1.NutanixIdentifierName, Name: &value}
}
}
}
// WithOsFamilyForAllNutanixMachines sets the osFamily for all Nutanix machines to value.
func WithOsFamilyForAllNutanixMachines(value anywherev1.OSFamily) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.OSFamily = value
}
}
}
// WithNutanixSubnetName returns a NutanixFiller that sets the subnet name for the Nutanix machine.
func WithNutanixSubnetName(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.Subnet = anywherev1.NutanixResourceIdentifier{Type: anywherev1.NutanixIdentifierName, Name: &value}
}
}
}
// WithNutanixPrismElementClusterName returns a NutanixFiller that sets the cluster name for the Nutanix machine.
func WithNutanixPrismElementClusterName(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.Cluster = anywherev1.NutanixResourceIdentifier{Type: anywherev1.NutanixIdentifierName, Name: &value}
}
}
}
// WithNutanixMachineTemplateImageUUID returns a NutanixFiller that sets the image UUID for the Nutanix machine.
func WithNutanixMachineTemplateImageUUID(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.Image = anywherev1.NutanixResourceIdentifier{Type: anywherev1.NutanixIdentifierUUID, UUID: &value}
}
}
}
// WithNutanixSubnetUUID returns a NutanixFiller that sets the subnet UUID for the Nutanix machine.
func WithNutanixSubnetUUID(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.Subnet = anywherev1.NutanixResourceIdentifier{Type: anywherev1.NutanixIdentifierUUID, UUID: &value}
}
}
}
// WithNutanixPrismElementClusterUUID returns a NutanixFiller that sets the cluster UUID for the Nutanix machine.
func WithNutanixPrismElementClusterUUID(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.Cluster = anywherev1.NutanixResourceIdentifier{Type: anywherev1.NutanixIdentifierUUID, UUID: &value}
}
}
}
// WithNutanixSSHAuthorizedKey returns a NutanixFiller that sets the SSH authorized key for the Nutanix machine.
func WithNutanixSSHAuthorizedKey(value string) NutanixFiller {
return func(config *NutanixConfig) {
for _, m := range config.machineConfigs {
m.Spec.Users = []anywherev1.UserConfiguration{
{
Name: anywherev1.DefaultNutanixMachineConfigUser,
SshAuthorizedKeys: []string{value},
},
}
}
}
}
| 208 |
eks-anywhere | aws | Go | package api
import (
"testing"
. "github.com/onsi/gomega"
"k8s.io/apimachinery/pkg/api/resource"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
func TestNutanixDatacenterConfigFillers(t *testing.T) {
g := NewWithT(t)
conf := nutanixConfig()
WithNutanixAdditionalTrustBundle("dGVzdEJ1bmRsZQ==")(conf) // "dGVzdEJ1bmRsZQ==" is "testBundle" in base64
g.Expect(conf.datacenterConfig.Spec.AdditionalTrustBundle).To(Equal("testBundle"))
WithNutanixEndpoint("prism-test.nutanix.com")(conf)
g.Expect(conf.datacenterConfig.Spec.Endpoint).To(Equal("prism-test.nutanix.com"))
WithNutanixPort(8080)(conf)
g.Expect(conf.datacenterConfig.Spec.Port).To(Equal(8080))
WithNutanixInsecure(true)(conf)
g.Expect(conf.datacenterConfig.Spec.Insecure).To(Equal(true))
}
func TestNutanixMachineConfigFillers(t *testing.T) {
g := NewWithT(t)
conf := nutanixConfig()
WithNutanixMachineMemorySize("4Gi")(conf)
WithNutanixMachineVCPUSocket(2)(conf)
WithNutanixMachineVCPUsPerSocket(2)(conf)
WithNutanixMachineSystemDiskSize("20Gi")(conf)
WithNutanixSubnetName("testSubnet")(conf)
WithNutanixPrismElementClusterName("testCluster")(conf)
WithNutanixMachineTemplateImageName("testImage")(conf)
WithOsFamilyForAllNutanixMachines("ubuntu")(conf)
WithNutanixSSHAuthorizedKey("testKey")(conf)
for _, machineConfig := range conf.machineConfigs {
g.Expect(machineConfig.Spec.MemorySize).To(Equal(resource.MustParse("4Gi")))
g.Expect(machineConfig.Spec.VCPUSockets).To(Equal(int32(2)))
g.Expect(machineConfig.Spec.VCPUsPerSocket).To(Equal(int32(2)))
g.Expect(machineConfig.Spec.SystemDiskSize).To(Equal(resource.MustParse("20Gi")))
g.Expect(machineConfig.Spec.Subnet.Type).To(Equal(anywherev1.NutanixIdentifierName))
g.Expect(*machineConfig.Spec.Subnet.Name).To(Equal("testSubnet"))
g.Expect(machineConfig.Spec.Cluster.Type).To(Equal(anywherev1.NutanixIdentifierName))
g.Expect(*machineConfig.Spec.Cluster.Name).To(Equal("testCluster"))
g.Expect(machineConfig.Spec.Image.Type).To(Equal(anywherev1.NutanixIdentifierName))
g.Expect(*machineConfig.Spec.Image.Name).To(Equal("testImage"))
g.Expect(machineConfig.Spec.Users[0].SshAuthorizedKeys[0]).To(Equal("testKey"))
g.Expect(machineConfig.Spec.OSFamily).To(Equal(anywherev1.Ubuntu))
}
WithNutanixSubnetUUID("90ad37a4-6dc0-4ae7-bcb3-a121dfb3fffa")(conf)
WithNutanixPrismElementClusterUUID("90ad37a4-6dc0-4ae7-bcb3-a121dfb3fffb")(conf)
WithNutanixMachineTemplateImageUUID("90ad37a4-6dc0-4ae7-bcb3-a121dfb3fffc")(conf)
for _, machineConfig := range conf.machineConfigs {
g.Expect(machineConfig.Spec.Subnet.Type).To(Equal(anywherev1.NutanixIdentifierUUID))
g.Expect(*machineConfig.Spec.Subnet.UUID).To(Equal("90ad37a4-6dc0-4ae7-bcb3-a121dfb3fffa"))
g.Expect(machineConfig.Spec.Cluster.Type).To(Equal(anywherev1.NutanixIdentifierUUID))
g.Expect(*machineConfig.Spec.Cluster.UUID).To(Equal("90ad37a4-6dc0-4ae7-bcb3-a121dfb3fffb"))
g.Expect(machineConfig.Spec.Image.Type).To(Equal(anywherev1.NutanixIdentifierUUID))
g.Expect(*machineConfig.Spec.Image.UUID).To(Equal("90ad37a4-6dc0-4ae7-bcb3-a121dfb3fffc"))
}
}
func nutanixConfig() *NutanixConfig {
return &NutanixConfig{
datacenterConfig: &anywherev1.NutanixDatacenterConfig{},
machineConfigs: map[string]*anywherev1.NutanixMachineConfig{},
}
}
| 77 |
eks-anywhere | aws | Go | package api
import (
"os"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
)
// OIDCConfigOpt updates an OIDC config.
type OIDCConfigOpt func(o *anywherev1.OIDCConfig)
// WithOIDCConfig builds a ClusterConfigFiller that adds a OIDCConfig with the
// given name and spec to the cluster config.
func WithOIDCConfig(name string, opts ...OIDCConfigOpt) ClusterConfigFiller {
return func(c *cluster.Config) {
if c.OIDCConfigs == nil {
c.OIDCConfigs = make(map[string]*anywherev1.OIDCConfig, 1)
}
oidc, ok := c.OIDCConfigs[name]
if !ok {
oidc = &anywherev1.OIDCConfig{
TypeMeta: metav1.TypeMeta{
APIVersion: anywherev1.SchemeBuilder.GroupVersion.String(),
Kind: anywherev1.OIDCConfigKind,
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
}
c.OIDCConfigs[name] = oidc
}
for _, opt := range opts {
opt(oidc)
}
}
}
func WithOIDCClientId(id string) OIDCConfigOpt {
return func(o *anywherev1.OIDCConfig) {
o.Spec.ClientId = id
}
}
func WithOIDCIssuerUrl(url string) OIDCConfigOpt {
return func(o *anywherev1.OIDCConfig) {
o.Spec.IssuerUrl = url
}
}
func WithOIDCUsernameClaim(claim string) OIDCConfigOpt {
return func(o *anywherev1.OIDCConfig) {
o.Spec.UsernameClaim = claim
}
}
func WithOIDCUsernamePrefix(prefix string) OIDCConfigOpt {
return func(o *anywherev1.OIDCConfig) {
o.Spec.UsernamePrefix = prefix
}
}
func WithOIDCGroupsClaim(claim string) OIDCConfigOpt {
return func(o *anywherev1.OIDCConfig) {
o.Spec.GroupsClaim = claim
}
}
func WithOIDCGroupsPrefix(prefix string) OIDCConfigOpt {
return func(o *anywherev1.OIDCConfig) {
o.Spec.GroupsPrefix = prefix
}
}
func WithOIDCRequiredClaims(claim, value string) OIDCConfigOpt {
return func(o *anywherev1.OIDCConfig) {
o.Spec.RequiredClaims = []anywherev1.OIDCConfigRequiredClaim{{
Claim: claim,
Value: value,
}}
}
}
func WithStringFromEnvVarOIDCConfig(envVar string, opt func(string) OIDCConfigOpt) OIDCConfigOpt {
return opt(os.Getenv(envVar))
}
| 91 |
eks-anywhere | aws | Go | package api
import (
"os"
"strings"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
)
type SnowConfig struct {
datacenterConfig *anywherev1.SnowDatacenterConfig
machineConfigs map[string]*anywherev1.SnowMachineConfig
ipPools map[string]*anywherev1.SnowIPPool
}
type SnowFiller func(config SnowConfig)
// SnowToConfigFiller transforms a set of SnowFiller's in a single ClusterConfigFiller.
func SnowToConfigFiller(fillers ...SnowFiller) ClusterConfigFiller {
return func(c *cluster.Config) {
updateSnow(c, fillers...)
}
}
func updateSnow(config *cluster.Config, fillers ...SnowFiller) {
if config.SnowIPPools == nil {
config.SnowIPPools = map[string]*anywherev1.SnowIPPool{}
}
sc := SnowConfig{
datacenterConfig: config.SnowDatacenter,
machineConfigs: config.SnowMachineConfigs,
ipPools: config.SnowIPPools,
}
for _, f := range fillers {
f(sc)
}
}
func WithSnowStringFromEnvVar(envVar string, opt func(string) SnowFiller) SnowFiller {
return opt(os.Getenv(envVar))
}
func WithSnowAMIIDForAllMachines(id string) SnowFiller {
return func(config SnowConfig) {
for _, m := range config.machineConfigs {
m.Spec.AMIID = id
}
}
}
// WithSnowInstanceTypeForAllMachines specifies an instance type for all the snow machine configs.
func WithSnowInstanceTypeForAllMachines(instanceType string) SnowFiller {
return func(config SnowConfig) {
for _, m := range config.machineConfigs {
m.Spec.InstanceType = instanceType
}
}
}
func WithSnowPhysicalNetworkConnectorForAllMachines(connectorType anywherev1.PhysicalNetworkConnectorType) SnowFiller {
return func(config SnowConfig) {
for _, m := range config.machineConfigs {
m.Spec.PhysicalNetworkConnector = connectorType
}
}
}
func WithSnowSshKeyNameForAllMachines(keyName string) SnowFiller {
return func(config SnowConfig) {
for _, m := range config.machineConfigs {
m.Spec.SshKeyName = keyName
}
}
}
func WithSnowDevicesForAllMachines(devices string) SnowFiller {
return func(config SnowConfig) {
for _, m := range config.machineConfigs {
m.Spec.Devices = strings.Split(devices, ",")
}
}
}
func WithSnowMachineConfig(name string, fillers ...SnowMachineConfigFiller) SnowFiller {
return func(config SnowConfig) {
m, ok := config.machineConfigs[name]
if !ok {
m = &anywherev1.SnowMachineConfig{
TypeMeta: metav1.TypeMeta{
Kind: anywherev1.SnowMachineConfigKind,
APIVersion: anywherev1.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
}
config.machineConfigs[name] = m
}
FillSnowMachineConfig(m, fillers...)
}
}
// WithOsFamilyForAllSnowMachines sets the OSFamily in the SnowMachineConfig.
func WithOsFamilyForAllSnowMachines(value anywherev1.OSFamily) SnowFiller {
return func(config SnowConfig) {
for _, m := range config.machineConfigs {
m.Spec.OSFamily = value
}
}
}
// WithChangeForAllSnowMachines applies the same change to all SnowMachineConfigs.
func WithChangeForAllSnowMachines(change SnowMachineConfigFiller) SnowFiller {
return func(config SnowConfig) {
for _, m := range config.machineConfigs {
change(m)
}
}
}
// WithSnowIPPool sets a SnowIPPool.
func WithSnowIPPool(name, ipStart, ipEnd, gateway, subnet string) SnowFiller {
return func(config SnowConfig) {
config.ipPools[name] = &anywherev1.SnowIPPool{
TypeMeta: metav1.TypeMeta{
Kind: anywherev1.SnowIPPoolKind,
APIVersion: anywherev1.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
Spec: anywherev1.SnowIPPoolSpec{
Pools: []anywherev1.IPPool{
{
IPStart: ipStart,
IPEnd: ipEnd,
Subnet: subnet,
Gateway: gateway,
},
},
},
}
}
}
| 151 |
eks-anywhere | aws | Go | package api
import (
"strings"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
snowv1 "github.com/aws/eks-anywhere/pkg/providers/snow/api/v1beta1"
)
type SnowMachineConfigFiller func(m *anywherev1.SnowMachineConfig)
func FillSnowMachineConfig(m *anywherev1.SnowMachineConfig, fillers ...SnowMachineConfigFiller) {
for _, f := range fillers {
f(m)
}
}
func WithSnowMachineDefaultValues() SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
m.Spec.InstanceType = anywherev1.DefaultSnowInstanceType
m.Spec.PhysicalNetworkConnector = anywherev1.DefaultSnowPhysicalNetworkConnectorType
m.Spec.SshKeyName = anywherev1.DefaultSnowSSHKeyName
}
}
func WithSnowAMIID(id string) SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
m.Spec.AMIID = id
}
}
// WithSnowInstanceType specifies an instance type for the snow machine config.
func WithSnowInstanceType(instanceType string) SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
m.Spec.InstanceType = instanceType
}
}
func WithSnowPhysicalNetworkConnector(connectorType anywherev1.PhysicalNetworkConnectorType) SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
m.Spec.PhysicalNetworkConnector = connectorType
}
}
func WithSnowSshKeyName(keyName string) SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
m.Spec.SshKeyName = keyName
}
}
func WithSnowDevices(devices string) SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
m.Spec.Devices = strings.Split(devices, ",")
}
}
// WithDHCP configures one single primary DNI using DHCP for IP allocation.
func WithDHCP() SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
m.Spec.Network.DirectNetworkInterfaces = []anywherev1.SnowDirectNetworkInterface{
{
DHCP: true,
Primary: true,
},
}
}
}
// WithStaticIP configures one single primary DNI using static ip for IP allocation.
func WithStaticIP(poolName string) SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
m.Spec.Network.DirectNetworkInterfaces = []anywherev1.SnowDirectNetworkInterface{
{
Primary: true,
IPPoolRef: &anywherev1.Ref{
Kind: anywherev1.SnowIPPoolKind,
Name: poolName,
},
},
}
}
}
// WithSnowContainersVolumeSize sets the container volume size for a SnowMachineConfig.
func WithSnowContainersVolumeSize(size int64) SnowMachineConfigFiller {
return func(m *anywherev1.SnowMachineConfig) {
if m.Spec.ContainersVolume == nil {
m.Spec.ContainersVolume = &snowv1.Volume{}
}
m.Spec.ContainersVolume.Size = size
}
}
| 93 |
eks-anywhere | aws | Go | package api
import (
"fmt"
corev1 "k8s.io/api/core/v1"
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
// MasterTaint will be deprecated from kubernetes version 1.25 onwards.
func MasterTaint() corev1.Taint {
return corev1.Taint{
Key: "node-role.kubernetes.io/master",
Effect: corev1.TaintEffectNoSchedule,
}
}
// ControlPlaneTaint has been added from 1.24 onwards.
func ControlPlaneTaint() corev1.Taint {
return corev1.Taint{
Key: "node-role.kubernetes.io/control-plane",
Effect: corev1.TaintEffectNoSchedule,
}
}
// ValidateControlPlaneTaints will validate that a controlPlane node has the expected taints.
func ValidateControlPlaneTaints(controlPlane v1alpha1.ControlPlaneConfiguration, node corev1.Node) (err error) {
cpTaints := controlPlane.Taints
// if no taints are specified, kubeadm defaults it to a well-known control plane taint.
// so, we make sure to check for that well-known taint if no taints are provided in the spec.
var taintsValid bool
if cpTaints == nil {
taintsValid = validateDefaultControlPlaneTaints(node)
} else {
taintsValid = v1alpha1.TaintsSliceEqual(cpTaints, node.Spec.Taints)
}
if !taintsValid {
return fmt.Errorf("taints on control plane node %v and corresponding control plane configuration do not match; configured taints: %v; node taints: %v",
node.Name, cpTaints, node.Spec.Taints)
}
return nil
}
// ValidateControlPlaneNoTaints will validate that a controlPlane has no taints, for example in the case of a single node cluster.
func ValidateControlPlaneNoTaints(controlPlane v1alpha1.ControlPlaneConfiguration, node corev1.Node) (err error) {
valid := len(controlPlane.Taints) == 0 && len(node.Spec.Taints) == 0
if !valid {
return fmt.Errorf("taints on control plane node %v or corresponding control plane configuration found; configured taints: %v; node taints: %v",
node.Name, controlPlane.Taints, node.Spec.Taints)
}
return nil
}
// ValidateWorkerNodeTaints will validate that a worker node has the expected taints in the worker node group configuration.
func ValidateWorkerNodeTaints(w v1alpha1.WorkerNodeGroupConfiguration, node corev1.Node) (err error) {
valid := v1alpha1.TaintsSliceEqual(node.Spec.Taints, w.Taints)
if !valid {
return fmt.Errorf("taints on node %v and corresponding worker node group configuration %v do not match", node.Name, w.Name)
}
return nil
}
func validateDefaultControlPlaneTaints(node corev1.Node) bool {
// Due to the transition from "master" to "control-plane", CP nodes can have one or both
// of these taints, depending on the k8s version. So checking that the node has at least one
// of them.
masterTaint := MasterTaint()
cpTaint := ControlPlaneTaint()
for _, v := range node.Spec.Taints {
if taintEqual(v, masterTaint) || taintEqual(v, cpTaint) {
return true
}
}
return false
}
func taintEqual(a, b corev1.Taint) bool {
return a.Key == b.Key && a.Effect == b.Effect && a.Value == b.Value
}
| 86 |
eks-anywhere | aws | Go | package api
import (
"os"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
"github.com/aws/eks-anywhere/pkg/providers"
)
type TinkerbellConfig struct {
clusterName string
datacenterConfig *anywherev1.TinkerbellDatacenterConfig
machineConfigs map[string]*anywherev1.TinkerbellMachineConfig
templateConfigs map[string]*anywherev1.TinkerbellTemplateConfig
}
// TinkerbellFiller updates a TinkerbellConfig.
type TinkerbellFiller func(config TinkerbellConfig)
// TinkerbellToConfigFiller transforms a set of TinkerbellFiller's in a single ClusterConfigFiller.
func TinkerbellToConfigFiller(fillers ...TinkerbellFiller) ClusterConfigFiller {
return func(c *cluster.Config) {
updateTinkerbell(c, fillers...)
}
}
// updateTinkerbell updates the Tinkerbell datacenter, machine configs and
// template configs in the cluster.Config by applying all the fillers.
func updateTinkerbell(config *cluster.Config, fillers ...TinkerbellFiller) {
tc := TinkerbellConfig{
clusterName: config.Cluster.Name,
datacenterConfig: config.TinkerbellDatacenter,
machineConfigs: config.TinkerbellMachineConfigs,
templateConfigs: config.TinkerbellTemplateConfigs,
}
for _, f := range fillers {
f(tc)
}
}
func WithTinkerbellServer(value string) TinkerbellFiller {
return func(config TinkerbellConfig) {
config.datacenterConfig.Spec.TinkerbellIP = value
}
}
func WithTinkerbellOSImageURL(value string) TinkerbellFiller {
return func(config TinkerbellConfig) {
config.datacenterConfig.Spec.OSImageURL = value
}
}
// WithHookImagesURLPath modify HookImagesURL, it's useful for airgapped testing.
func WithHookImagesURLPath(value string) TinkerbellFiller {
return func(config TinkerbellConfig) {
config.datacenterConfig.Spec.HookImagesURLPath = value
}
}
func WithStringFromEnvVarTinkerbell(envVar string, opt func(string) TinkerbellFiller) TinkerbellFiller {
return opt(os.Getenv(envVar))
}
func WithOsFamilyForAllTinkerbellMachines(value anywherev1.OSFamily) TinkerbellFiller {
return func(config TinkerbellConfig) {
for _, m := range config.machineConfigs {
m.Spec.OSFamily = value
}
}
}
func WithImageUrlForAllTinkerbellMachines(value string) TinkerbellFiller {
return func(config TinkerbellConfig) {
for _, t := range config.templateConfigs {
for _, task := range t.Spec.Template.Tasks {
for _, action := range task.Actions {
if action.Name == "stream-image" {
action.Environment["IMG_URL"] = value
}
}
}
}
}
}
func WithSSHAuthorizedKeyForAllTinkerbellMachines(key string) TinkerbellFiller {
return func(config TinkerbellConfig) {
for _, m := range config.machineConfigs {
if len(m.Spec.Users) == 0 {
m.Spec.Users = []anywherev1.UserConfiguration{{}}
}
m.Spec.Users[0].Name = "ec2-user"
m.Spec.Users[0].SshAuthorizedKeys = []string{key}
}
}
}
func WithHardwareSelectorLabels() TinkerbellFiller {
return func(config TinkerbellConfig) {
clusterName := config.clusterName
cpName := providers.GetControlPlaneNodeName(clusterName)
workerName := clusterName
cpMachineConfig := config.machineConfigs[cpName]
cpMachineConfig.Spec.HardwareSelector = map[string]string{HardwareLabelTypeKeyName: ControlPlane}
config.machineConfigs[cpName] = cpMachineConfig
workerMachineConfig := config.machineConfigs[workerName]
workerMachineConfig.Spec.HardwareSelector = map[string]string{HardwareLabelTypeKeyName: Worker}
config.machineConfigs[workerName] = workerMachineConfig
}
}
func WithTinkerbellEtcdMachineConfig() TinkerbellFiller {
return func(config TinkerbellConfig) {
clusterName := config.clusterName
name := providers.GetEtcdNodeName(clusterName)
_, ok := config.machineConfigs[name]
if !ok {
m := &anywherev1.TinkerbellMachineConfig{
TypeMeta: metav1.TypeMeta{
Kind: anywherev1.TinkerbellMachineConfigKind,
APIVersion: anywherev1.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
Spec: anywherev1.TinkerbellMachineConfigSpec{
HardwareSelector: map[string]string{HardwareLabelTypeKeyName: ExternalEtcd},
TemplateRef: anywherev1.Ref{
Name: clusterName,
Kind: anywherev1.TinkerbellTemplateConfigKind,
},
},
}
config.machineConfigs[name] = m
}
}
}
// WithStringFromEnvVarTinkerbellMachineFiller runs a TinkerbellMachineFiller function with an envVar value.
func WithStringFromEnvVarTinkerbellMachineFiller(envVar string, opt func(string) TinkerbellMachineFiller) TinkerbellMachineFiller {
return opt(os.Getenv(envVar))
}
// TinkerbellMachineFiller updates a TinkerbellMachineConfig.
type TinkerbellMachineFiller func(machineConfig *anywherev1.TinkerbellMachineConfig)
// WithSSHAuthorizedKeyForTinkerbellMachineConfig updates the SSHAuthorizedKey for a TinkerbellMachineConfig.
func WithSSHAuthorizedKeyForTinkerbellMachineConfig(key string) TinkerbellMachineFiller {
return func(machineConfig *anywherev1.TinkerbellMachineConfig) {
if len(machineConfig.Spec.Users) == 0 {
machineConfig.Spec.Users = []anywherev1.UserConfiguration{{}}
}
machineConfig.Spec.Users[0].Name = "ec2-user"
machineConfig.Spec.Users[0].SshAuthorizedKeys = []string{key}
}
}
// WithOsFamilyForTinkerbellMachineConfig updates the OSFamily of a TinkerbellMachineConfig.
func WithOsFamilyForTinkerbellMachineConfig(value anywherev1.OSFamily) TinkerbellMachineFiller {
return func(machineConfig *anywherev1.TinkerbellMachineConfig) {
machineConfig.Spec.OSFamily = value
}
}
// WithCustomTinkerbellMachineConfig generates a TinkerbellMachineConfig from a hardware selector.
func WithCustomTinkerbellMachineConfig(selector string, machineConfigFillers ...TinkerbellMachineFiller) TinkerbellFiller {
return func(config TinkerbellConfig) {
if _, ok := config.machineConfigs[selector]; !ok {
m := &anywherev1.TinkerbellMachineConfig{
TypeMeta: metav1.TypeMeta{
Kind: anywherev1.TinkerbellMachineConfigKind,
APIVersion: anywherev1.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: selector,
},
Spec: anywherev1.TinkerbellMachineConfigSpec{
HardwareSelector: map[string]string{HardwareLabelTypeKeyName: selector},
},
}
for _, f := range machineConfigFillers {
f(m)
}
config.machineConfigs[selector] = m
}
}
}
| 199 |
eks-anywhere | aws | Go | package api
import (
"os"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
)
type VSphereConfig struct {
datacenterConfig *anywherev1.VSphereDatacenterConfig
machineConfigs map[string]*anywherev1.VSphereMachineConfig
}
type VSphereFiller func(config VSphereConfig)
// VSphereToConfigFiller transforms a set of VSphereFiller's in a single ClusterConfigFiller.
func VSphereToConfigFiller(fillers ...VSphereFiller) ClusterConfigFiller {
return func(c *cluster.Config) {
updateVSphere(c, fillers...)
}
}
// updateVSphere updates the vSphere datacenter and machine configs in the
// cluster.Config by applying all the fillers.
func updateVSphere(config *cluster.Config, fillers ...VSphereFiller) {
vc := VSphereConfig{
datacenterConfig: config.VSphereDatacenter,
machineConfigs: config.VSphereMachineConfigs,
}
for _, f := range fillers {
f(vc)
}
}
func WithOsFamilyForAllMachines(value anywherev1.OSFamily) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.OSFamily = value
}
}
}
// WithTagsForAllMachines add provided tags to all machines.
func WithTagsForAllMachines(value []string) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.TagIDs = value
}
}
}
func WithNumCPUsForAllMachines(value int) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.NumCPUs = value
}
}
}
func WithDiskGiBForAllMachines(value int) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.DiskGiB = value
}
}
}
func WithMemoryMiBForAllMachines(value int) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.MemoryMiB = value
}
}
}
func WithTLSInsecure(value bool) VSphereFiller {
return func(config VSphereConfig) {
config.datacenterConfig.Spec.Insecure = value
}
}
func WithTLSThumbprint(value string) VSphereFiller {
return func(config VSphereConfig) {
config.datacenterConfig.Spec.Thumbprint = value
}
}
func WithTemplateForAllMachines(value string) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.Template = value
}
}
}
func WithStoragePolicyNameForAllMachines(value string) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.StoragePolicyName = value
}
}
}
func WithVSphereConfigNamespaceForAllMachinesAndDatacenter(ns string) VSphereFiller {
return func(config VSphereConfig) {
config.datacenterConfig.Namespace = ns
for _, m := range config.machineConfigs {
m.Namespace = ns
}
}
}
func WithSSHAuthorizedKeyForAllMachines(key string) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
setSSHKeyForFirstUser(m, key)
}
}
}
func WithServer(value string) VSphereFiller {
return func(config VSphereConfig) {
config.datacenterConfig.Spec.Server = value
}
}
func WithResourcePoolForAllMachines(value string) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.ResourcePool = value
}
}
}
func WithNetwork(value string) VSphereFiller {
return func(config VSphereConfig) {
config.datacenterConfig.Spec.Network = value
}
}
func WithFolderForAllMachines(value string) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.Folder = value
}
}
}
func WithDatastoreForAllMachines(value string) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.Datastore = value
}
}
}
func WithDatacenter(value string) VSphereFiller {
return func(config VSphereConfig) {
config.datacenterConfig.Spec.Datacenter = value
}
}
// WithCloneModeForAllMachines sets the CloneMode for all VSphereMachineConfigs.
func WithCloneModeForAllMachines(value anywherev1.CloneMode) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
m.Spec.CloneMode = value
}
}
}
// WithNTPServersForAllMachines sets NTP servers for all VSphereMachineConfigs.
func WithNTPServersForAllMachines(servers []string) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
if m.Spec.HostOSConfiguration == nil {
m.Spec.HostOSConfiguration = &anywherev1.HostOSConfiguration{}
}
if m.Spec.HostOSConfiguration.NTPConfiguration == nil {
m.Spec.HostOSConfiguration.NTPConfiguration = &anywherev1.NTPConfiguration{}
}
m.Spec.HostOSConfiguration.NTPConfiguration.Servers = servers
}
}
}
// WithBottlerocketConfigurationForAllMachines sets Bottlerocket configuration for all VSphereMachineConfigs.
func WithBottlerocketConfigurationForAllMachines(value *anywherev1.BottlerocketConfiguration) VSphereFiller {
return func(config VSphereConfig) {
for _, m := range config.machineConfigs {
if m.Spec.HostOSConfiguration == nil {
m.Spec.HostOSConfiguration = &anywherev1.HostOSConfiguration{}
}
m.Spec.HostOSConfiguration.BottlerocketConfiguration = value
}
}
}
func WithVSphereStringFromEnvVar(envVar string, opt func(string) VSphereFiller) VSphereFiller {
return opt(os.Getenv(envVar))
}
func WithVSphereBoolFromEnvVar(envVar string, opt func(bool) VSphereFiller) VSphereFiller {
return opt(os.Getenv(envVar) == "true")
}
func WithVSphereMachineConfig(name string, fillers ...VSphereMachineConfigFiller) VSphereFiller {
return func(config VSphereConfig) {
m, ok := config.machineConfigs[name]
if !ok {
m = &anywherev1.VSphereMachineConfig{
TypeMeta: metav1.TypeMeta{
Kind: anywherev1.VSphereMachineConfigKind,
APIVersion: anywherev1.SchemeBuilder.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
}
config.machineConfigs[name] = m
}
FillVSphereMachineConfig(m, fillers...)
}
}
| 230 |
eks-anywhere | aws | Go | package api
import (
"os"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
type VSphereMachineConfigFiller func(m *anywherev1.VSphereMachineConfig)
func FillVSphereMachineConfig(m *anywherev1.VSphereMachineConfig, fillers ...VSphereMachineConfigFiller) {
for _, f := range fillers {
f(m)
}
}
func WithVSphereMachineDefaultValues() VSphereMachineConfigFiller {
return func(m *anywherev1.VSphereMachineConfig) {
m.Spec.DiskGiB = anywherev1.DefaultVSphereDiskGiB
m.Spec.NumCPUs = anywherev1.DefaultVSphereNumCPUs
m.Spec.MemoryMiB = anywherev1.DefaultVSphereMemoryMiB
m.Spec.OSFamily = anywherev1.DefaultVSphereOSFamily
}
}
func WithDatastore(value string) VSphereMachineConfigFiller {
return func(m *anywherev1.VSphereMachineConfig) {
m.Spec.Datastore = value
}
}
func WithFolder(value string) VSphereMachineConfigFiller {
return func(m *anywherev1.VSphereMachineConfig) {
m.Spec.Folder = value
}
}
// WithTags add provided tags to all machines.
func WithTags(value []string) VSphereMachineConfigFiller {
return func(m *anywherev1.VSphereMachineConfig) {
m.Spec.TagIDs = value
}
}
func WithResourcePool(value string) VSphereMachineConfigFiller {
return func(m *anywherev1.VSphereMachineConfig) {
m.Spec.ResourcePool = value
}
}
func WithStoragePolicyName(value string) VSphereMachineConfigFiller {
return func(m *anywherev1.VSphereMachineConfig) {
m.Spec.StoragePolicyName = value
}
}
func WithTemplate(value string) VSphereMachineConfigFiller {
return func(m *anywherev1.VSphereMachineConfig) {
m.Spec.Template = value
}
}
func WithSSHKey(value string) VSphereMachineConfigFiller {
return func(m *anywherev1.VSphereMachineConfig) {
setSSHKeyForFirstUser(m, value)
}
}
// WithStringFromEnvVar returns a VSphereMachineConfigFiller function with the value from an envVar passed to it.
func WithStringFromEnvVar(envVar string, opt func(string) VSphereMachineConfigFiller) VSphereMachineConfigFiller {
return opt(os.Getenv(envVar))
}
func setSSHKeyForFirstUser(m *anywherev1.VSphereMachineConfig, key string) {
m.SetUserDefaults()
m.Spec.Users[0].SshAuthorizedKeys = []string{key}
}
| 78 |
eks-anywhere | aws | Go | package api
import (
"strings"
"github.com/pkg/errors"
"k8s.io/apimachinery/pkg/runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/yaml"
)
func CleanupPathsFromYaml(yamlContent []byte, paths []string) ([]byte, error) {
m := make(map[string]interface{})
if err := yaml.Unmarshal(yamlContent, &m); err != nil {
return nil, err
}
deletePaths(m, paths)
newYaml, err := yaml.Marshal(&m)
if err != nil {
return nil, err
}
return newYaml, nil
}
// CleanupPathsInObject unsets or nullifies the provided paths in a give kubernetes Object.
func CleanupPathsInObject[T any, PT interface {
*T
client.Object
}](obj PT, paths []string,
) error {
clusterObj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(obj)
if err != nil {
return errors.Wrap(err, "failed converting cluster to unstructured")
}
deletePaths(clusterObj, paths)
*obj = *new(T)
if err := runtime.DefaultUnstructuredConverter.FromUnstructured(clusterObj, obj); err != nil {
return errors.Wrap(err, "failed converting back to cluster from unstructured")
}
return nil
}
func deletePaths(m map[string]interface{}, paths []string) {
for _, p := range paths {
deletePath(m, strings.Split(p, "."))
}
}
func deletePath(m map[string]interface{}, path []string) {
currentElement := m
for i := 0; i < len(path)-1; i++ {
p := strings.TrimSuffix(path[i], "[]")
isArray := len(path[i]) != len(p)
e, ok := currentElement[p]
if !ok {
return
}
if isArray {
arrayElement, arrayOk := e.([]interface{})
if !arrayOk {
return
}
for _, o := range arrayElement {
currentElement, ok = o.(map[string]interface{})
if !ok {
continue
}
deletePath(currentElement, path[i+1:])
}
return
}
currentElement, ok = e.(map[string]interface{})
if !ok {
return
}
}
delete(currentElement, path[len(path)-1])
}
| 92 |
eks-anywhere | aws | Go | package api
import (
"testing"
. "github.com/onsi/gomega"
)
func TestDeletePaths(t *testing.T) {
tests := []struct {
name string
obj, wantObj map[string]interface{}
paths []string
}{
{
name: "delete nested paths, array and property from array of objects",
obj: map[string]interface{}{
"spec": map[string]interface{}{
"workers": []interface{}{
map[string]interface{}{
"name": "name1",
"count": 1,
},
map[string]interface{}{
"name": "name2",
"count": 2,
},
},
"controlPlane": map[string]interface{}{
"ip": "ip",
"apiServer": map[string]interface{}{
"cipher": "cipher1",
"flags": []string{
"flag1",
"flag2",
},
},
},
},
},
paths: []string{
"spec.controlPlane.apiServer.flags",
"spec.workers[].name",
"spec.controlPlane.ip",
},
wantObj: map[string]interface{}{
"spec": map[string]interface{}{
"workers": []interface{}{
map[string]interface{}{
"count": 1,
},
map[string]interface{}{
"count": 2,
},
},
"controlPlane": map[string]interface{}{
"apiServer": map[string]interface{}{
"cipher": "cipher1",
},
},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
g := NewWithT(t)
deletePaths(tt.obj, tt.paths)
g.Expect(tt.obj).To(Equal(tt.wantObj))
})
}
}
| 73 |
eks-anywhere | aws | Go | package awsiam
import (
"fmt"
"runtime"
eksdv1alpha1 "github.com/aws/eks-distro-build-tooling/release/api/v1alpha1"
"github.com/aws/eks-anywhere/internal/pkg/files"
)
const awsIamClientBinary = "aws-iam-authenticator"
func DownloadAwsIamAuthClient(eksdRelease *eksdv1alpha1.Release) error {
uri, err := getAwsIamAuthClientUri(eksdRelease, getKernelName())
if err != nil {
return fmt.Errorf("getting %s uri: %v", awsIamClientBinary, err)
}
err = files.GzipFileDownloadExtract(uri, awsIamClientBinary, "bin")
if err != nil {
return fmt.Errorf("downloading %s binary: %v", awsIamClientBinary, err)
}
return nil
}
func getKernelName() string {
return runtime.GOOS
}
func getAwsIamAuthClientUri(eksdRelease *eksdv1alpha1.Release, kernalName string) (string, error) {
for _, component := range eksdRelease.Status.Components {
if component.Name == awsIamClientBinary {
for _, asset := range component.Assets {
if asset.Type == "Archive" && asset.OS == kernalName && asset.Arch[0] == "amd64" {
return asset.Archive.URI, nil
}
}
}
}
return "", fmt.Errorf("component %s not found in EKS-D release spec", awsIamClientBinary)
}
| 42 |
eks-anywhere | aws | Go | package conformance
import (
"bytes"
"fmt"
"golang.org/x/sys/unix"
"github.com/aws/eks-anywhere/internal/pkg/files"
)
const (
destinationFile = "sonobuoy"
sonobuoyDarwin = "https://github.com/vmware-tanzu/sonobuoy/releases/download/v0.53.2/sonobuoy_0.53.2_darwin_amd64.tar.gz"
sonobuoyLinux = "https://github.com/vmware-tanzu/sonobuoy/releases/download/v0.53.2/sonobuoy_0.53.2_linux_amd64.tar.gz"
)
func Download() error {
var err error
var utsname unix.Utsname
err = unix.Uname(&utsname)
if err != nil {
return fmt.Errorf("uname call failure: %v", err)
}
var downloadFile string
sysname := string(bytes.Trim(utsname.Sysname[:], "\x00"))
if sysname == "Darwin" {
downloadFile = sonobuoyDarwin
} else {
downloadFile = sonobuoyLinux
}
fmt.Println("Downloading sonobuoy for " + sysname + ": " + downloadFile)
err = files.GzipFileDownloadExtract(downloadFile, destinationFile, "")
if err != nil {
return fmt.Errorf("failed to download sonobouy: %v", err)
}
return nil
}
| 40 |
eks-anywhere | aws | Go | package conformance
import (
"context"
"github.com/aws/eks-anywhere/pkg/executables"
)
func RunTests(ctx context.Context, contextName string, args ...string) (string, error) {
sonobuoy := executables.BuildSonobuoyExecutable()
return sonobuoy.Run(ctx, contextName, args...)
}
func GetResults(ctx context.Context, contextName string, args ...string) (string, error) {
sonobuoy := executables.BuildSonobuoyExecutable()
return sonobuoy.GetResults(ctx, contextName, args...)
}
| 18 |
eks-anywhere | aws | Go | package ec2
import (
"encoding/base64"
"fmt"
"math/rand"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/aws/eks-anywhere/pkg/logger"
"github.com/aws/eks-anywhere/pkg/retrier"
)
var dockerLogsUserData = `
#!/bin/bash
cat <<'EOF' >> /etc/docker/daemon.json
{
"log-driver": "journald",
"log-level": "debug"
}
EOF
systemctl restart docker --no-block
`
func CreateInstance(session *session.Session, amiId, key, tag, instanceProfileName, subnetId, name string) (string, error) {
r := retrier.New(180*time.Minute, retrier.WithBackoffFactor(1.5), retrier.WithRetryPolicy(func(totalRetries int, err error) (retry bool, wait time.Duration) {
// EC2 Request token bucket has a refill rate of 2 request tokens
// per second, so waiting between 5 and 10 seconds per retry with a backoff factor of 1.5 should be sufficient
if isThrottleError(err) && totalRetries < 50 {
fmt.Println("Throttled, retrying")
maxWait := 10
minWait := 5
waitWithJitter := time.Duration(rand.Intn(maxWait-minWait)+minWait) * time.Second
return true, waitWithJitter
}
return false, 0
}))
service := ec2.New(session)
var result *ec2.Reservation
err := r.Retry(func() error {
var err error
result, err = service.RunInstances(&ec2.RunInstancesInput{
ImageId: aws.String(amiId),
InstanceType: aws.String("t3.2xlarge"),
MinCount: aws.Int64(1),
MaxCount: aws.Int64(1),
BlockDeviceMappings: []*ec2.BlockDeviceMapping{
{
DeviceName: aws.String("/dev/xvda"),
Ebs: &ec2.EbsBlockDevice{
VolumeSize: aws.Int64(100),
},
},
},
IamInstanceProfile: &ec2.IamInstanceProfileSpecification{
Name: aws.String(instanceProfileName),
},
SubnetId: aws.String(subnetId),
TagSpecifications: []*ec2.TagSpecification{
{
ResourceType: aws.String("instance"),
Tags: []*ec2.Tag{
{
Key: aws.String(key),
Value: aws.String(tag),
},
{
Key: aws.String("Name"),
Value: aws.String(name),
},
},
},
},
UserData: aws.String(base64.StdEncoding.EncodeToString([]byte(dockerLogsUserData))),
MetadataOptions: &ec2.InstanceMetadataOptionsRequest{HttpTokens: aws.String("required"), HttpPutResponseHopLimit: aws.Int64(int64(2))},
})
return err
})
if err != nil {
return "", fmt.Errorf("retries exhausted when trying to create instances: %v", err)
}
logger.V(2).Info("Waiting until the instance starts running")
input := &ec2.DescribeInstancesInput{
InstanceIds: []*string{
result.Instances[0].InstanceId,
},
}
err = service.WaitUntilInstanceRunning(input)
if err != nil {
return "", fmt.Errorf("waiting for instance: %v", err)
}
logger.V(2).Info("Instance is running")
return *result.Instances[0].InstanceId, nil
}
func isThrottleError(err error) bool {
if aerr, ok := err.(awserr.Error); ok {
if aerr.Code() == "RequestLimitExceeded" {
return true
}
}
return false
}
| 114 |
eks-anywhere | aws | Go | package ec2
import (
"fmt"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/aws/eks-anywhere/pkg/logger"
)
func ListInstances(session *session.Session, key string, value string, maxAge float64) ([]*string, error) {
service := ec2.New(session)
var instanceList []*string
input := &ec2.DescribeInstancesInput{
Filters: []*ec2.Filter{
{
Name: aws.String("tag:" + key),
Values: []*string{
aws.String(value),
},
},
{
Name: aws.String("instance-state-name"),
Values: []*string{
aws.String("running"),
aws.String("pending"),
aws.String("stopping"),
aws.String("stopped"),
},
},
},
}
for {
result, err := service.DescribeInstances(input)
if err != nil {
return nil, fmt.Errorf("describing EC2 instances: %v", err)
}
reservations := result.Reservations
for _, reservation := range reservations {
instances := reservation.Instances
for _, instance := range instances {
instanceAge := time.Since(*(instance.LaunchTime)).Seconds()
logger.V(4).Info("EC2", "instance_id", *(instance.InstanceId), "age_seconds", instanceAge)
failed := true
for _, tag := range instance.Tags {
if *(tag.Key) == "Integration-Test-Done" && *(tag.Value) == "TRUE" {
logger.V(4).Info("Tests ran successfully on this instance")
failed = false
}
}
if instanceAge > maxAge || !failed {
logger.V(4).Info("Adding the instance in the deletion list")
instanceList = append(instanceList, instance.InstanceId)
} else {
logger.V(4).Info("Not adding the instance in the deletion list")
}
}
}
if result.NextToken != nil {
input.NextToken = result.NextToken
} else {
break
}
}
return instanceList, nil
}
| 73 |
eks-anywhere | aws | Go | package ec2
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ec2"
)
func TagInstance(session *session.Session, instanceId, key, value string) error {
service := ec2.New(session)
_, err := service.CreateTags(&ec2.CreateTagsInput{
Resources: []*string{&instanceId},
Tags: []*ec2.Tag{
{
Key: aws.String(key),
Value: aws.String(value),
},
},
})
if err != nil {
return fmt.Errorf("tagging instance: %v", err)
}
return nil
}
| 28 |
eks-anywhere | aws | Go | package ec2
import (
"fmt"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ec2"
)
const defaultInstanceIDBlockSize = 500
// TerminateEc2Instances terminates EC2 instances by calling the AWS API.
func TerminateEc2Instances(session *session.Session, instanceIDs []*string) error {
service := ec2.New(session)
for _, instanceIDChunk := range makeChunks(instanceIDs, defaultInstanceIDBlockSize) {
input := &ec2.TerminateInstancesInput{
InstanceIds: instanceIDChunk,
}
if _, err := service.TerminateInstances(input); err != nil {
return fmt.Errorf("terminating EC2 instances: %v", err)
}
}
return nil
}
func makeChunks[T any](elements []T, chunkSize int) [][]T {
elementsSize := len(elements)
if elementsSize == 0 {
return [][]T{}
}
chunksSize := (elementsSize + chunkSize - 1) / chunkSize
chunks := make([][]T, 0, chunksSize)
start := 0
for i := 0; i < chunksSize-1; i++ {
end := start + chunkSize
chunks = append(chunks, elements[start:end])
start = end
}
chunks = append(chunks, elements[start:elementsSize])
return chunks
}
| 45 |
eks-anywhere | aws | Go | package ec2
import (
"testing"
. "github.com/onsi/gomega"
"github.com/aws/eks-anywhere/pkg/utils/ptr"
)
func TestMakeChunks(t *testing.T) {
tests := []struct {
name string
elements []*int
chunkSize int
want [][]*int
}{
{
name: "empty elements",
elements: []*int{},
chunkSize: 2,
want: [][]*int{},
},
{
name: "nil elements",
elements: nil,
chunkSize: 2,
want: [][]*int{},
},
{
name: "even length, exact division",
elements: []*int{
ptr.Int(1), ptr.Int(2),
ptr.Int(3), ptr.Int(4),
ptr.Int(5), ptr.Int(6),
ptr.Int(7), ptr.Int(8),
},
chunkSize: 2,
want: [][]*int{
{ptr.Int(1), ptr.Int(2)},
{ptr.Int(3), ptr.Int(4)},
{ptr.Int(5), ptr.Int(6)},
{ptr.Int(7), ptr.Int(8)},
},
},
{
name: "odd length, exact division",
elements: []*int{
ptr.Int(1), ptr.Int(2), ptr.Int(3),
ptr.Int(4), ptr.Int(5), ptr.Int(6),
ptr.Int(7), ptr.Int(8), ptr.Int(9),
},
chunkSize: 3,
want: [][]*int{
{ptr.Int(1), ptr.Int(2), ptr.Int(3)},
{ptr.Int(4), ptr.Int(5), ptr.Int(6)},
{ptr.Int(7), ptr.Int(8), ptr.Int(9)},
},
},
{
name: "even length, non exact division",
elements: []*int{
ptr.Int(1), ptr.Int(2),
ptr.Int(3), ptr.Int(4),
ptr.Int(5), ptr.Int(6),
ptr.Int(7),
},
chunkSize: 2,
want: [][]*int{
{ptr.Int(1), ptr.Int(2)},
{ptr.Int(3), ptr.Int(4)},
{ptr.Int(5), ptr.Int(6)},
{ptr.Int(7)},
},
},
{
name: "odd length, non exact division",
elements: []*int{
ptr.Int(1), ptr.Int(2), ptr.Int(3),
ptr.Int(4), ptr.Int(5), ptr.Int(6),
ptr.Int(7),
},
chunkSize: 3,
want: [][]*int{
{ptr.Int(1), ptr.Int(2), ptr.Int(3)},
{ptr.Int(4), ptr.Int(5), ptr.Int(6)},
{ptr.Int(7)},
},
},
{
name: "length same as chunk size",
elements: []*int{
ptr.Int(1), ptr.Int(2),
ptr.Int(3), ptr.Int(4),
ptr.Int(5), ptr.Int(6),
ptr.Int(7),
},
chunkSize: 7,
want: [][]*int{
{
ptr.Int(1), ptr.Int(2),
ptr.Int(3), ptr.Int(4),
ptr.Int(5), ptr.Int(6),
ptr.Int(7),
},
},
},
{
name: "length same smaller than chunk size",
elements: []*int{
ptr.Int(1), ptr.Int(2),
ptr.Int(3), ptr.Int(4),
ptr.Int(5), ptr.Int(6),
ptr.Int(7),
},
chunkSize: 17,
want: [][]*int{
{
ptr.Int(1), ptr.Int(2),
ptr.Int(3), ptr.Int(4),
ptr.Int(5), ptr.Int(6),
ptr.Int(7),
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
g := NewWithT(t)
g.Expect(makeChunks(tt.elements, tt.chunkSize)).To(Equal(tt.want))
})
}
}
| 134 |
eks-anywhere | aws | Go | package files
import (
"archive/tar"
"compress/gzip"
"fmt"
"net/http"
"os"
"path/filepath"
"strings"
"github.com/aws/eks-anywhere/pkg/logger"
untar "github.com/aws/eks-anywhere/pkg/tar"
)
// GzipFileDownloadExtract downloads and extracts a specific file to destination.
func GzipFileDownloadExtract(uri, fileToExtract, destination string) error {
targetFile := filepath.Join(destination, fileToExtract)
if _, err := os.Stat(targetFile); err == nil {
logger.V(4).Info("File already exists", "file", targetFile)
return nil
}
client := &http.Client{}
resp, err := client.Get(uri)
if err != nil {
return fmt.Errorf("getting download: %v", err)
}
defer resp.Body.Close()
gzf, err := gzip.NewReader(resp.Body)
if err != nil {
return fmt.Errorf("initializing gzip: %v", err)
}
defer gzf.Close()
router := singleFileRouter{
fileName: fileToExtract,
folder: destination,
}
return untar.Untar(gzf, router)
}
type singleFileRouter struct {
folder string
fileName string
}
func (s singleFileRouter) ExtractPath(header *tar.Header) string {
if strings.TrimPrefix(header.Name, "./") != s.fileName {
return ""
}
return filepath.Join(s.folder, header.FileInfo().Name())
}
| 56 |
eks-anywhere | aws | Go | package files_test
import (
"os"
"path/filepath"
"testing"
. "github.com/onsi/gomega"
"github.com/aws/eks-anywhere/internal/pkg/files"
"github.com/aws/eks-anywhere/internal/test"
)
func TestGzipFileDownloadExtract(t *testing.T) {
g := NewWithT(t)
server := test.NewHTTPServerForFile(t, "testdata/dummy1.tar.gz")
dst := "testdata/bin"
file := "dummy1"
g.Expect(os.MkdirAll(dst, os.ModePerm))
t.Cleanup(func() {
os.RemoveAll(dst)
})
g.Expect(files.GzipFileDownloadExtract(server.URL, file, dst)).To(Succeed())
targetFile := filepath.Join(dst, file)
g.Expect(targetFile).To(BeARegularFile())
test.AssertFilesEquals(t, targetFile, "testdata/dummy1")
}
| 28 |
eks-anywhere | aws | Go | package nutanix
import (
"context"
"fmt"
"strings"
prismgoclient "github.com/nutanix-cloud-native/prism-go-client"
"github.com/nutanix-cloud-native/prism-go-client/utils"
v3 "github.com/nutanix-cloud-native/prism-go-client/v3"
"github.com/aws/eks-anywhere/pkg/providers/nutanix"
)
// PrismClient is a interface that provides useful functions for performing Prism operations.
type PrismClient interface {
GetImageUUIDFromName(ctx context.Context, imageName string) (*string, error)
GetClusterUUIDFromName(ctx context.Context, clusterName string) (*string, error)
GetSubnetUUIDFromName(ctx context.Context, subnetName string) (*string, error)
}
type client struct {
v3.Client
}
// NewPrismClient returns an implementation of the PrismClient interface.
func NewPrismClient(endpoint, port string, insecure bool) (PrismClient, error) {
creds := nutanix.GetCredsFromEnv()
nutanixCreds := prismgoclient.Credentials{
URL: fmt.Sprintf("%s:%s", endpoint, port),
Username: creds.PrismCentral.Username,
Password: creds.PrismCentral.Password,
Endpoint: endpoint,
Port: port,
Insecure: insecure,
}
pclient, err := v3.NewV3Client(nutanixCreds)
if err != nil {
return nil, err
}
return &client{*pclient}, nil
}
// GetImageUUIDFromName retrieves the image uuid from the given image name.
func (c *client) GetImageUUIDFromName(ctx context.Context, imageName string) (*string, error) {
res, err := c.V3.ListImage(ctx, &v3.DSMetadata{
Filter: utils.StringPtr(fmt.Sprintf("name==%s", imageName)),
})
if err != nil || len(res.Entities) == 0 {
return nil, fmt.Errorf("failed to find image by name %q: %v", imageName, err)
}
if len(res.Entities) > 1 {
return nil, fmt.Errorf("found more than one (%v) image with name %q", len(res.Entities), imageName)
}
return res.Entities[0].Metadata.UUID, nil
}
// GetClusterUUIDFromName retrieves the cluster uuid from the given cluster name.
//
//nolint:gocyclo
func (c *client) GetClusterUUIDFromName(ctx context.Context, clusterName string) (*string, error) {
res, err := c.V3.ListCluster(ctx, &v3.DSMetadata{
Filter: utils.StringPtr(fmt.Sprintf("name==%s", clusterName)),
})
if err != nil {
return nil, fmt.Errorf("failed to find cluster by name %q: %v", clusterName, err)
}
entities := make([]*v3.ClusterIntentResponse, 0)
for _, entity := range res.Entities {
if entity.Status != nil && entity.Status.Resources != nil && entity.Status.Resources.Config != nil {
serviceList := entity.Status.Resources.Config.ServiceList
isPrismCentral := false
for _, svc := range serviceList {
// Prism Central is also internally a cluster, but we filter that out here as we only care about prism element clusters
if svc != nil && strings.ToUpper(*svc) == "PRISM_CENTRAL" {
isPrismCentral = true
}
}
if !isPrismCentral && *entity.Spec.Name == clusterName {
entities = append(entities, entity)
}
}
}
if len(entities) == 0 {
return nil, fmt.Errorf("failed to find cluster by name %q: %v", clusterName, err)
}
if len(entities) > 1 {
return nil, fmt.Errorf("found more than one (%v) cluster with name %q", len(entities), clusterName)
}
return entities[0].Metadata.UUID, nil
}
// GetSubnetUUIDFromName retrieves the subnet uuid from the given subnet name.
func (c *client) GetSubnetUUIDFromName(ctx context.Context, subnetName string) (*string, error) {
res, err := c.V3.ListSubnet(ctx, &v3.DSMetadata{
Filter: utils.StringPtr(fmt.Sprintf("name==%s", subnetName)),
})
if err != nil || len(res.Entities) == 0 {
return nil, fmt.Errorf("failed to find subnet by name %q: %v", subnetName, err)
}
if len(res.Entities) > 1 {
return nil, fmt.Errorf("found more than one (%v) subnet with name %q", len(res.Entities), subnetName)
}
return res.Entities[0].Metadata.UUID, nil
}
| 113 |
eks-anywhere | aws | Go | package oidc
import (
"encoding/json"
"fmt"
jose "gopkg.in/square/go-jose.v2"
)
type keyResponse struct {
Keys []jose.JSONWebKey `json:"keys"`
}
func GetKeyID(keysBytes []byte) (string, error) {
keys, err := parseKeys(keysBytes)
if err != nil {
return "", err
}
if len(keys.Keys) != 1 {
return "", fmt.Errorf("keys array in keys.json should have size 1 but has size %d", len(keys.Keys))
}
return keys.Keys[0].KeyID, nil
}
func parseKeys(bytes []byte) (*keyResponse, error) {
keys := &keyResponse{}
err := json.Unmarshal(bytes, keys)
if err != nil {
return nil, fmt.Errorf("parsing keys.json to get kid: %v", err)
}
return keys, nil
}
| 36 |
eks-anywhere | aws | Go | package oidc
import (
"bytes"
"crypto/rand"
"crypto/rsa"
"crypto/sha1"
"crypto/x509"
"encoding/json"
"encoding/pem"
"fmt"
jose "gopkg.in/square/go-jose.v2"
)
type MinimalProvider struct {
Discovery, Keys, PrivateKey []byte
KeyID string
}
type discoveryResponse struct {
Issuer string `json:"issuer"`
JwksUri string `json:"jwks_uri"`
AuthorizationEndpoint string `json:"authorization_endpoint"`
ResponseTypesSupported []string `json:"response_types_supported"`
SubjectTypesSupported []string `json:"subject_types_supported"`
IdTokenSigningAlgValuesSupported []string `json:"id_token_signing_alg_values_supported"`
ClaimsSupported []string `json:"claims_supported"`
}
func GenerateMinimalProvider(issuerURL string) (*MinimalProvider, error) {
privateKey, err := rsa.GenerateKey(rand.Reader, 1024)
if err != nil {
return nil, fmt.Errorf("generating rsa key for OIDC: %v", err)
}
pubKey := &privateKey.PublicKey
pubKeyEncoded, err := marshalPubKey(pubKey)
if err != nil {
return nil, err
}
// Set the key id to the sha1 of the pubkey
sha := sha1.New()
_, err = sha.Write(pubKeyEncoded)
if err != nil {
return nil, fmt.Errorf("generating sha1 checksum for pubkey: %v", err)
}
kid := fmt.Sprintf("%x", sha.Sum(nil))
keys := []jose.JSONWebKey{
{
Key: pubKey,
KeyID: kid,
Algorithm: string(jose.RS256),
Use: "sig",
},
}
keysJson, err := json.MarshalIndent(keyResponse{Keys: keys}, "", " ")
if err != nil {
return nil, fmt.Errorf("marshalling keys.json for OIDC: %v", err)
}
d := &discoveryResponse{
Issuer: issuerURL,
JwksUri: fmt.Sprintf("%s/keys.json", issuerURL),
AuthorizationEndpoint: "urn:kubernetes:programmatic_authorization",
ResponseTypesSupported: []string{"id_token"},
SubjectTypesSupported: []string{"public"},
IdTokenSigningAlgValuesSupported: []string{"RS256"},
ClaimsSupported: []string{"sub", "iss"},
}
discoveryJson, err := json.MarshalIndent(d, "", " ")
if err != nil {
return nil, fmt.Errorf("marshalling json discovery for OIDC: %v", err)
}
marshalledPrivateKey, err := marshalPrivateKey(privateKey)
if err != nil {
return nil, err
}
return &MinimalProvider{
Discovery: discoveryJson,
Keys: keysJson,
PrivateKey: marshalledPrivateKey,
KeyID: kid,
}, nil
}
func marshalPubKey(pubKey *rsa.PublicKey) ([]byte, error) {
pubKeyBytes, err := x509.MarshalPKIXPublicKey(pubKey)
if err != nil {
return nil, fmt.Errorf("marshalling pub key for oidc provider: %v", err)
}
pubKeyBlock := &pem.Block{
Type: "PUBLIC KEY",
Bytes: pubKeyBytes,
}
buffer := &bytes.Buffer{}
err = pem.Encode(buffer, pubKeyBlock)
if err != nil {
return nil, fmt.Errorf("encoding public key for oidc provider: %v", err)
}
return buffer.Bytes(), nil
}
func marshalPrivateKey(k *rsa.PrivateKey) ([]byte, error) {
pubKeyBytes := x509.MarshalPKCS1PrivateKey(k)
keyBlock := &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: pubKeyBytes,
}
buffer := &bytes.Buffer{}
err := pem.Encode(buffer, keyBlock)
if err != nil {
return nil, fmt.Errorf("encoding private key for oidc provider: %v", err)
}
return buffer.Bytes(), nil
}
| 129 |
eks-anywhere | aws | Go | package oidc_test
import (
"crypto/x509"
"encoding/json"
"encoding/pem"
"testing"
"github.com/aws/eks-anywhere/internal/pkg/oidc"
"github.com/aws/eks-anywhere/internal/test"
)
func TestGenerateMinimalProvider(t *testing.T) {
tests := []struct {
testName string
issuerURL string
wantDiscoveryFile string
}{
{
testName: "s3 provider",
issuerURL: "https://s3-us-west-2.amazonaws.com/oidc-test-84hfke94j49",
wantDiscoveryFile: "testdata/s3_discovery_expected.json",
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
got, err := oidc.GenerateMinimalProvider(tt.issuerURL)
if err != nil {
t.Fatalf("GenerateServerFiles() error = %v, want nil", err)
}
test.AssertContentToFile(t, string(got.Discovery), tt.wantDiscoveryFile)
block, _ := pem.Decode(got.PrivateKey)
_, err = x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
t.Fatalf("GenerateServerFiles() = PrivateKey is not a valid rsa key: %v", err)
}
gotKeys := make(map[string][]map[string]string)
err = json.Unmarshal(got.Keys, &gotKeys)
if err != nil {
t.Errorf("GenerateServerFiles() = Keys is not a valid json: %v", err)
}
keys := gotKeys["keys"]
if len(keys) != 1 {
t.Errorf("GenerateServerFiles() = len(Keys.Keys) = %d, want 1", len(keys))
}
key := keys[0]
if key["kid"] != got.KeyID {
t.Errorf("GenerateServerFiles() = Keys.keys[0].kid = %s, want %s", key["kid"], got.KeyID)
}
if key["kty"] != "RSA" {
t.Errorf("GenerateServerFiles() = Keys.keys[0].kty = %s, want %s", key["kty"], "RSA")
}
if key["alg"] != "RS256" {
t.Errorf("GenerateServerFiles() = Keys.keys[0].alg = %s, want %s", key["alg"], "RS256")
}
if key["use"] != "sig" {
t.Errorf("GenerateServerFiles() = Keys.keys[0].use = %s, want %s", key["use"], "sig")
}
if key["e"] != "AQAB" {
t.Errorf("GenerateServerFiles() = Keys.keys[0].e = %s, want %s", key["e"], "AQAB")
}
})
}
}
| 76 |
eks-anywhere | aws | Go | package oidc
import (
"crypto/x509"
"encoding/pem"
"fmt"
"os"
"time"
jose "gopkg.in/square/go-jose.v2"
"gopkg.in/square/go-jose.v2/jwt"
)
type oidcTokenClaim struct {
Issuer string `json:"iss,omitempty"`
Subject string `json:"sub,omitempty"`
kid string
keyFile string
Role string `json:"role,omitempty"`
Email string `json:"email,omitempty"`
Audience []string `json:"aud,omitempty"`
Groups []string `json:"groups,omitempty"`
ExpiresAt int64 `json:"exp,omitempty"`
IssuedAt int64 `json:"iat,omitempty"`
NotBefore int64 `json:"nbf,omitempty"`
KubernetesAccess string `json:"kubernetesAccess,omitempty"`
}
type JWTOpt func(*oidcTokenClaim)
func NewJWT(issuerName, kid, keyFile string, opts ...JWTOpt) (string, error) {
now := time.Now()
o := &oidcTokenClaim{
Issuer: fmt.Sprintf("https://%s", issuerName),
Audience: []string{},
ExpiresAt: now.Add(time.Hour * 24).Unix(),
IssuedAt: now.Unix(),
NotBefore: now.Unix(),
Groups: []string{},
kid: kid,
keyFile: keyFile,
}
for _, opt := range opts {
opt(o)
}
return o.generateToken()
}
func WithEmail(email string) JWTOpt {
return func(o *oidcTokenClaim) {
o.Email = email
}
}
func WithGroup(group string) JWTOpt {
return func(o *oidcTokenClaim) {
o.Groups = append(o.Groups, group)
}
}
func WithRole(role string) JWTOpt {
return func(o *oidcTokenClaim) {
o.Role = role
}
}
func WithKubernetesAccess(access bool) JWTOpt {
return func(o *oidcTokenClaim) {
o.KubernetesAccess = fmt.Sprintf("%t", access)
}
}
func WithAudience(audience string) JWTOpt {
return func(o *oidcTokenClaim) {
o.Audience = append(o.Audience, audience)
}
}
func WithSubject(subject string) JWTOpt {
return func(o *oidcTokenClaim) {
o.Subject = subject
}
}
func (o *oidcTokenClaim) generateToken() (string, error) {
keyContent, err := os.ReadFile(o.keyFile)
if err != nil {
return "", fmt.Errorf("could not read key file: %v", err)
}
block, _ := pem.Decode(keyContent)
if block == nil {
return "", fmt.Errorf("decoding PEM file %s", o.keyFile)
}
privKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return "", fmt.Errorf("parsing key content of %s: %v", o.keyFile, err)
}
jwkKey := &jose.JSONWebKey{
Algorithm: string(jose.RS256),
Key: privKey,
KeyID: o.kid,
Use: "sig",
}
signer, err := jose.NewSigner(
jose.SigningKey{
Algorithm: jose.RS256,
Key: jwkKey,
},
nil,
)
if err != nil {
return "", fmt.Errorf("failed to create signer: %v", err)
}
token, err := jwt.Signed(signer).Claims(o).CompactSerialize()
if err != nil {
return "", fmt.Errorf("signing token: %v", err)
}
return token, nil
}
| 126 |
eks-anywhere | aws | Go | package s3
import (
"fmt"
"github.com/aws/aws-sdk-go/aws/session"
)
func GetBucketPublicURL(session *session.Session, bucket string) string {
return fmt.Sprintf("https://s3-%s.amazonaws.com/%s", *session.Config.Region, bucket)
}
| 12 |
eks-anywhere | aws | Go | package s3
import (
"fmt"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/eks-anywhere/pkg/logger"
)
func CleanUpS3Bucket(session *session.Session, bucket string, maxAge float64) error {
service := s3.New(session)
input := &s3.ListObjectsV2Input{
Bucket: aws.String(bucket),
}
result, err := service.ListObjectsV2(input)
if err != nil {
return fmt.Errorf("listing s3 bucket objects: %v", err)
}
var objectList []*string
logger.V(4).Info("Listing s3 bucket objects")
for _, object := range result.Contents {
logger.V(4).Info("s3", "object_name", *(object.Key), "last_modified", *(object.LastModified))
lastModifiedTime := time.Since(*(object.LastModified)).Seconds()
if lastModifiedTime > maxAge && *(object.Key) != "eksctl/eksctl" && *(object.Key) != "generated-artifacts/" {
logger.V(4).Info("Adding object for deletion")
objectList = append(objectList, object.Key)
} else {
logger.V(4).Info("Skipping object deletion")
}
}
if len(objectList) != 0 {
for _, object := range objectList {
logger.V(4).Info("Deleting", "object", *object)
_, err = service.DeleteObject(
&s3.DeleteObjectInput{
Bucket: aws.String(bucket),
Key: object,
},
)
if err != nil {
return fmt.Errorf("deleting object %s: %v", *object, err)
}
}
} else {
logger.V(4).Info("No s3 objects for deletion")
}
return nil
}
| 57 |
eks-anywhere | aws | Go | package s3
import (
"fmt"
"io"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/aws-sdk-go/service/s3/s3manager"
)
func Download(session *session.Session, key, bucket string) ([]byte, error) {
b := aws.NewWriteAtBuffer([]byte{})
if err := download(session, key, bucket, b); err != nil {
return nil, err
}
return b.Bytes(), nil
}
func download(session *session.Session, key, bucket string, w io.WriterAt) error {
d := s3manager.NewDownloader(session)
_, err := d.Download(w, &s3.GetObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
})
if err != nil {
return fmt.Errorf("downloading [%s] from [%s] bucket: %v", key, bucket, err)
}
return nil
}
func DownloadToDisk(session *session.Session, key, bucket, dst string) error {
file, err := os.Create(dst)
if err != nil {
return fmt.Errorf("unable to create destination file %s: %v", dst, err)
}
defer file.Close()
if err := download(session, key, bucket, file); err != nil {
return err
}
return nil
}
| 49 |
eks-anywhere | aws | Go | package s3
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
)
func ObjectPresent(session *session.Session, key, bucket string) (bool, error) {
s := s3.New(session)
_, err := s.HeadObject(&s3.HeadObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
})
if err != nil {
if aerr, ok := err.(awserr.Error); ok && aerr.Code() == "NotFound" {
return false, nil
}
return false, fmt.Errorf("getting s3 object head to check if present: %v", err)
}
return true, nil
}
| 27 |
eks-anywhere | aws | Go | package s3
import (
"bytes"
"fmt"
"io"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3/s3manager"
)
type UploadOpt func(*s3manager.UploadInput)
func WithPublicRead() UploadOpt {
return func(s *s3manager.UploadInput) {
s.ACL = aws.String("public-read")
}
}
func UploadFile(session *session.Session, file, key, bucket string, opts ...UploadOpt) error {
fileBody, err := os.Open(file)
if err != nil {
return fmt.Errorf("opening file for upload: %v", err)
}
return upload(session, fileBody, key, bucket, opts...)
}
func Upload(session *session.Session, body []byte, key, bucket string, opts ...UploadOpt) error {
return upload(session, bytes.NewBuffer(body), key, bucket, opts...)
}
func upload(session *session.Session, body io.Reader, key, bucket string, opts ...UploadOpt) error {
s3Uploader := s3manager.NewUploader(session)
i := &s3manager.UploadInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
Body: body,
}
for _, opt := range opts {
opt(i)
}
_, err := s3Uploader.Upload(i)
if err != nil {
return fmt.Errorf("uploading to s3: %v", err)
}
return nil
}
| 54 |
eks-anywhere | aws | Go | package ssm
import (
"fmt"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
)
type ActivationInfo struct {
ActivationCode string
ActivationID string
}
func CreateActivation(session *session.Session, instanceName, role string) (*ActivationInfo, error) {
s := ssm.New(session)
request := ssm.CreateActivationInput{
DefaultInstanceName: &instanceName,
Description: &instanceName,
IamRole: &role,
}
result, err := s.CreateActivation(&request)
if err != nil {
return nil, fmt.Errorf("failed to activate ssm instance %s: %v", instanceName, err)
}
return &ActivationInfo{ActivationCode: *result.ActivationCode, ActivationID: *result.ActivationId}, nil
}
func DeleteActivation(session *session.Session, activationId string) (*ssm.DeleteActivationOutput, error) {
s := ssm.New(session)
request := ssm.DeleteActivationInput{
ActivationId: &activationId,
}
result, err := s.DeleteActivation(&request)
if err != nil {
return nil, fmt.Errorf("failed to delete ssm activation: %v", err)
}
return result, nil
}
| 46 |
eks-anywhere | aws | Go | package ssm
import (
"fmt"
"math"
"strconv"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/go-logr/logr"
"github.com/aws/eks-anywhere/pkg/retrier"
)
const ssmLogGroup = "/eks-anywhere/test/e2e"
var initE2EDirCommand = "mkdir -p /home/e2e/bin && cd /home/e2e"
// WaitForSSMReady waits for the SSM command to be ready.
func WaitForSSMReady(session *session.Session, instanceID string, timeout time.Duration) error {
err := retrier.Retry(10, 20*time.Second, func() error {
return Run(session, logr.Discard(), instanceID, "ls", timeout)
})
if err != nil {
return fmt.Errorf("waiting for ssm to be ready: %v", err)
}
return nil
}
type CommandOpt func(c *ssm.SendCommandInput)
func WithOutputToS3(bucket, dir string) CommandOpt {
return func(c *ssm.SendCommandInput) {
c.OutputS3BucketName = aws.String(bucket)
c.OutputS3KeyPrefix = aws.String(dir)
}
}
func WithOutputToCloudwatch() CommandOpt {
return func(c *ssm.SendCommandInput) {
cwEnabled := true
logGroup := ssmLogGroup
cw := ssm.CloudWatchOutputConfig{
CloudWatchLogGroupName: &logGroup,
CloudWatchOutputEnabled: &cwEnabled,
}
c.CloudWatchOutputConfig = &cw
}
}
var nonFinalStatuses = map[string]struct{}{
ssm.CommandInvocationStatusInProgress: {}, ssm.CommandInvocationStatusDelayed: {}, ssm.CommandInvocationStatusPending: {},
}
// Run runs the command using SSM on the instance corresponding to the instanceID.
func Run(session *session.Session, logger logr.Logger, instanceID, command string, timeout time.Duration, opts ...CommandOpt) error {
o, err := RunCommand(session, logger, instanceID, command, timeout, opts...)
if err != nil {
return err
}
if !o.Successful() {
return fmt.Errorf("ssm command returned not successful result %s: %s", *o.commandOut.Status, string(o.StdErr))
}
return nil
}
// RunCommand runs the command using SSM on the instance corresponding to the instanceID.
func RunCommand(session *session.Session, logger logr.Logger, instanceID, command string, timeout time.Duration, opts ...CommandOpt) (*RunOutput, error) {
service := ssm.New(session)
result, err := sendCommand(service, logger, instanceID, command, timeout, opts...)
if err != nil {
return nil, err
}
commandIn := &ssm.GetCommandInvocationInput{
CommandId: result.Command.CommandId,
InstanceId: aws.String(instanceID),
}
// Make sure ssm send command is registered
logger.Info("Waiting for ssm command to be registered", "commandId", commandIn.CommandId, "instanceID", commandIn.InstanceId)
err = retrier.Retry(10, 5*time.Second, func() error {
_, err := service.GetCommandInvocation(commandIn)
if err != nil {
return fmt.Errorf("getting ssm command invocation: %v", err)
}
return nil
})
if err != nil {
return nil, fmt.Errorf("waiting for ssm command to be registered: %v", err)
}
logger.Info("Waiting for ssm command to finish")
var commandOut *ssm.GetCommandInvocationOutput
// Making the retrier wait for longer than the provided SSM timeout to make sure
// we always get the output results.
r := retrier.New(timeout+5*time.Minute, retrier.WithMaxRetries(math.MaxInt, 60*time.Second))
err = r.Retry(func() error {
var err error
commandOut, err = service.GetCommandInvocation(commandIn)
if err != nil {
return err
}
status := *commandOut.Status
if isFinalStatus(status) {
logger.V(4).Info("SSM command finished", "status", status, "commandId", *result.Command.CommandId)
return nil
}
return fmt.Errorf("command still running with status %s", status)
})
if err != nil {
return nil, fmt.Errorf("retries exhausted running ssm command: %v", err)
}
return buildRunOutput(commandOut), nil
}
func sendCommand(service *ssm.SSM, logger logr.Logger, instanceID, command string, timeout time.Duration, opts ...CommandOpt) (*ssm.SendCommandOutput, error) {
in := &ssm.SendCommandInput{
DocumentName: aws.String("AWS-RunShellScript"),
InstanceIds: []*string{aws.String(instanceID)},
Parameters: map[string][]*string{"commands": {aws.String(initE2EDirCommand), aws.String(command)}, "executionTimeout": {aws.String(strconv.FormatFloat(timeout.Seconds(), 'f', 0, 64))}},
}
for _, opt := range opts {
opt(in)
}
var result *ssm.SendCommandOutput
r := retrier.New(timeout, retrier.WithRetryPolicy(func(totalRetries int, err error) (retry bool, wait time.Duration) {
if request.IsErrorThrottle(err) && totalRetries < 60 {
return true, 60 * time.Second
}
return false, 0
}))
err := r.Retry(func() error {
var err error
logger.V(4).Info("Running ssm command", "cmd", command)
result, err = service.SendCommand(in)
if err != nil {
return err
}
return nil
})
if err != nil {
return nil, fmt.Errorf("retries exhausted sending ssm command: %v", err)
}
logger.V(4).Info("SSM command started", "commandId", result.Command.CommandId)
if in.OutputS3BucketName != nil {
logger.V(4).Info(
"SSM command output to S3", "url",
fmt.Sprintf("s3://%s/%s/%s/%s/awsrunShellScript/0.awsrunShellScript/stderr", *in.OutputS3BucketName, *in.OutputS3KeyPrefix, *result.Command.CommandId, instanceID),
)
}
return result, nil
}
func isFinalStatus(status string) bool {
_, nonFinalStatus := nonFinalStatuses[status]
return !nonFinalStatus
}
| 174 |
eks-anywhere | aws | Go | package ssm
import (
"fmt"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
)
func GetInstanceByActivationId(session *session.Session, id string) (*ssm.InstanceInformation, error) {
s := ssm.New(session)
instanceActivationIdKey := "ActivationIds"
input := ssm.DescribeInstanceInformationInput{
Filters: []*ssm.InstanceInformationStringFilter{
{Key: &instanceActivationIdKey, Values: []*string{&id}},
},
}
output, err := s.DescribeInstanceInformation(&input)
if err != nil {
return nil, fmt.Errorf("failed to describe ssm instance %s: %v", id, err)
}
infoList := output.InstanceInformationList
if len(infoList) == 0 {
return nil, fmt.Errorf("no ssm instance with name %s: %v", id, err)
}
return infoList[0], nil
}
func DeregisterInstance(session *session.Session, id string) (*ssm.DeregisterManagedInstanceOutput, error) {
s := ssm.New(session)
input := ssm.DeregisterManagedInstanceInput{
InstanceId: &id,
}
output, err := s.DeregisterManagedInstance(&input)
if err != nil {
return nil, fmt.Errorf("failed to deregister ssm instance %s: %v", id, err)
}
return output, nil
}
| 46 |
eks-anywhere | aws | Go | package ssm
import "github.com/aws/aws-sdk-go/service/ssm"
type RunOutput struct {
commandOut *ssm.GetCommandInvocationOutput
CommandId string
StdOut, StdErr []byte
}
func buildRunOutput(commandOut *ssm.GetCommandInvocationOutput) *RunOutput {
return &RunOutput{
commandOut: commandOut,
CommandId: *commandOut.CommandId,
StdOut: []byte(*commandOut.StandardOutputContent),
StdErr: []byte(*commandOut.StandardErrorContent),
}
}
func (r *RunOutput) Successful() bool {
return *r.commandOut.Status == ssm.CommandInvocationStatusSuccess
}
| 23 |
eks-anywhere | aws | Go | package vsphere
import (
"context"
"encoding/json"
"fmt"
"github.com/aws/eks-anywhere/pkg/executables"
"github.com/aws/eks-anywhere/pkg/filewriter"
)
type OVFDeployOptions struct {
Name string `json:"Name"`
PowerOn bool `json:"PowerOn"`
DiskProvisioning string `json:"DiskProvisioning"`
WaitForIP bool `json:"WaitForIP"`
NetworkMappings []NetworkMapping `json:"NetworkMapping"`
Annotation string `json:"Annotation"`
PropertyMapping []OVFProperty `json:"PropertyMapping"`
InjectOvfEnv bool `json:"InjectOvfEnv"`
}
type OVFProperty struct {
Key string `json:"Key"`
Value string `json:"Value"`
}
type NetworkMapping struct {
Name string `json:"Name"`
Network string `json:"Network"`
}
func DeployTemplate(envMap map[string]string, library, templateName, vmName, deployFolder, datacenter, datastore, resourcePool string, opts OVFDeployOptions) error {
context := context.Background()
executableBuilder, close, err := executables.InitInDockerExecutablesBuilder(context, executables.DefaultEksaImage())
if err != nil {
return fmt.Errorf("unable to initialize executables: %v", err)
}
defer close.CheckErr(context)
tmpWriter, _ := filewriter.NewWriter(vmName)
govc := executableBuilder.BuildGovcExecutable(tmpWriter, executables.WithGovcEnvMap(envMap))
defer govc.Close(context)
deployOptions, err := json.Marshal(opts)
if err != nil {
return fmt.Errorf("failed to marshall vm deployment options: %v", err)
}
// deploy template
if err := govc.DeployTemplate(context, library, templateName, vmName, deployFolder, datacenter, datastore, opts.NetworkMappings[0].Network, resourcePool, deployOptions); err != nil {
return fmt.Errorf("failed to deploy vm from library template: %v", err)
}
return nil
}
func TagVirtualMachine(envMap map[string]string, vmPath, tag string) error {
context := context.Background()
executableBuilder, close, err := executables.InitInDockerExecutablesBuilder(context, executables.DefaultEksaImage())
if err != nil {
return fmt.Errorf("unable to initialize executables: %v", err)
}
defer close.CheckErr(context)
tmpWriter, _ := filewriter.NewWriter(vmPath)
govc := executableBuilder.BuildGovcExecutable(tmpWriter, executables.WithGovcEnvMap(envMap))
defer govc.Close(context)
if err := govc.AddTag(context, vmPath, tag); err != nil {
return fmt.Errorf("failed to tag vm: %v", err)
}
return nil
}
| 75 |
eks-anywhere | aws | Go | package test
import (
"embed"
"fmt"
"path/filepath"
"runtime"
"testing"
eksdv1alpha1 "github.com/aws/eks-distro-build-tooling/release/api/v1alpha1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"sigs.k8s.io/yaml"
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/cluster"
"github.com/aws/eks-anywhere/pkg/files"
"github.com/aws/eks-anywhere/pkg/templater"
"github.com/aws/eks-anywhere/pkg/version"
releasev1alpha1 "github.com/aws/eks-anywhere/release/api/v1alpha1"
)
type ClusterSpecOpt func(*cluster.Spec)
//go:embed testdata
var configFS embed.FS
// DevEksaVersion can be used in tests.
var DevEksaVersion v1alpha1.EksaVersion = "v0.0.0-dev"
func NewClusterSpec(opts ...ClusterSpecOpt) *cluster.Spec {
s := &cluster.Spec{}
s.Config = &cluster.Config{
Cluster: &v1alpha1.Cluster{
ObjectMeta: metav1.ObjectMeta{
Name: "fluxTestCluster",
},
Spec: v1alpha1.ClusterSpec{
WorkerNodeGroupConfigurations: []v1alpha1.WorkerNodeGroupConfiguration{{}},
},
},
}
s.VersionsBundle = &cluster.VersionsBundle{
VersionsBundle: &releasev1alpha1.VersionsBundle{},
KubeDistro: &cluster.KubeDistro{},
}
s.Bundles = &releasev1alpha1.Bundles{}
for _, opt := range opts {
opt(s)
}
return s
}
func NewFullClusterSpec(t *testing.T, clusterConfigFile string) *cluster.Spec {
b := cluster.NewFileSpecBuilder(
files.NewReader(files.WithEmbedFS(configFS)),
version.Info{GitVersion: "v0.0.0-dev"},
cluster.WithReleasesManifest("embed:///testdata/releases.yaml"),
)
s, err := b.Build(clusterConfigFile)
if err != nil {
t.Fatalf("can't build cluster spec for tests: %v", err)
}
return s
}
// NewClusterSpecForCluster builds a compliant [cluster.Spec] from a Cluster using a test
// Bundles and EKS-D Release.
func NewClusterSpecForCluster(tb testing.TB, c *v1alpha1.Cluster) *cluster.Spec {
return NewClusterSpecForConfig(tb, &cluster.Config{Cluster: c})
}
// NewClusterSpecForConfig builds a compliant [cluster.Spec] from a [cluster.Config] using a test
// Bundles and EKS-D Release.
func NewClusterSpecForConfig(tb testing.TB, config *cluster.Config) *cluster.Spec {
spec, err := cluster.NewSpec(
config,
Bundles(tb),
EksdRelease(),
)
if err != nil {
tb.Fatalf("Failed to build cluster spec: %s", err)
}
return spec
}
// Bundles returs a test Bundles. All the paths to referenced manifests are valid and can be read.
func Bundles(tb testing.TB) *releasev1alpha1.Bundles {
content, err := configFS.ReadFile("testdata/bundles.yaml")
if err != nil {
tb.Fatalf("Failed to read embed bundles manifest: %s", err)
}
_, filename, _, ok := runtime.Caller(0)
if !ok {
tb.Fatal("Failed getting path to current file")
}
templateValues := map[string]string{
"TestPath": filepath.Dir(filename),
}
bundlesContent, err := templater.Execute(string(content), templateValues)
if err != nil {
tb.Fatalf("Failed writing new bundles file: %v", err)
}
bundles := &releasev1alpha1.Bundles{}
if err = yaml.Unmarshal(bundlesContent, bundles); err != nil {
tb.Fatalf("Failed to unmarshal bundles manifest: %s", err)
}
return bundles
}
// EksdReleaseFromTestData returns a test release struct for unit testing from a testdata file.
// See EksdRelease() for a static struct to test with.
func EksdReleaseFromTestData(t *testing.T) *eksdv1alpha1.Release {
t.Helper()
content, err := configFS.ReadFile("testdata/kubernetes-1-21-eks-4.yaml")
if err != nil {
t.Fatalf("Failed to read embed eksd release: %s", err)
}
eksd := &eksdv1alpha1.Release{}
if err = yaml.Unmarshal(content, eksd); err != nil {
t.Fatalf("Failed to unmarshal eksd manifest: %s", err)
}
return eksd
}
func SetTag(image *releasev1alpha1.Image, tag string) {
image.URI = fmt.Sprintf("%s:%s", image.Image(), tag)
}
| 139 |
eks-anywhere | aws | Go | package test
import (
"bytes"
"flag"
"fmt"
"log"
"os"
"os/exec"
"regexp"
"testing"
"github.com/aws/eks-anywhere/pkg/files"
"github.com/aws/eks-anywhere/pkg/filewriter"
)
var UpdateGoldenFiles = flag.Bool("update", false, "update golden files")
func AssertFilesEquals(t *testing.T, gotPath, wantPath string) {
t.Helper()
gotFile := ReadFile(t, gotPath)
processUpdate(t, wantPath, gotFile)
wantFile := ReadFile(t, wantPath)
if gotFile != wantFile {
cmd := exec.Command("diff", wantPath, gotPath)
result, err := cmd.Output()
if err != nil {
if exitError, ok := err.(*exec.ExitError); ok {
if exitError.ExitCode() == 1 {
t.Fatalf("Results diff expected actual:\n%s", string(result))
}
}
}
t.Fatalf("Files are different got =\n %s \n want =\n %s\n%s", gotFile, wantFile, err)
}
}
func AssertContentToFile(t *testing.T, gotContent, wantFile string) {
t.Helper()
if wantFile == "" {
return
}
processUpdate(t, wantFile, gotContent)
fileContent := ReadFile(t, wantFile)
if gotContent != fileContent {
diff, err := computeDiffBetweenContentAndFile([]byte(gotContent), wantFile)
if err != nil {
t.Fatalf("Content doesn't match file got =\n%s\n\n\nwant =\n%s\n", gotContent, fileContent)
}
if diff != "" {
t.Fatalf("Results diff expected actual for %s:\n%s", wantFile, string(diff))
}
}
}
func contentEqualToFile(gotContent []byte, wantFile string) (bool, error) {
if wantFile == "" && len(gotContent) == 0 {
return false, nil
}
fileContent, err := os.ReadFile(wantFile)
if err != nil {
return false, err
}
return bytes.Equal(gotContent, fileContent), nil
}
func computeDiffBetweenContentAndFile(content []byte, file string) (string, error) {
cmd := exec.Command("diff", "-u", file, "-")
cmd.Stdin = bytes.NewReader([]byte(content))
result, err := cmd.Output()
if err != nil {
if exitError, ok := err.(*exec.ExitError); ok && exitError.ExitCode() == 1 {
return string(result), nil
}
return "", fmt.Errorf("computing the difference between content and file %s: %v", file, err)
}
return "", nil
}
func processUpdate(t *testing.T, filePath, content string) {
if *UpdateGoldenFiles {
if err := os.WriteFile(filePath, []byte(content), 0o644); err != nil {
t.Fatalf("failed to update golden file %s: %v", filePath, err)
}
log.Printf("Golden file updated: %s", filePath)
}
}
func ReadFileAsBytes(t *testing.T, file string) []byte {
bytesRead, err := os.ReadFile(file)
if err != nil {
t.Fatalf("File [%s] reading error in test: %v", file, err)
}
return bytesRead
}
func ReadFile(t *testing.T, file string) string {
return string(ReadFileAsBytes(t, file))
}
func NewWriter(t *testing.T) (dir string, writer filewriter.FileWriter) {
dir, err := os.MkdirTemp(".", SanitizePath(t.Name())+"-")
if err != nil {
t.Fatalf("error setting up folder for test: %v", err)
}
t.Cleanup(cleanupDir(t, dir))
writer, err = filewriter.NewWriter(dir)
if err != nil {
t.Fatalf("error creating writer with folder for test: %v", err)
}
return dir, writer
}
func cleanupDir(t *testing.T, dir string) func() {
return func() {
if !t.Failed() {
os.RemoveAll(dir)
}
}
}
var sanitizePathChars = regexp.MustCompile(`[^\w-]`)
const sanitizePathReplacementChar = "_"
// SanitizePath sanitizes s so its usable as a path name. For safety, it assumes all characters that are not
// A-Z, a-z, 0-9, _ or - are illegal and replaces them with _.
func SanitizePath(s string) string {
return sanitizePathChars.ReplaceAllString(s, sanitizePathReplacementChar)
}
// NewFileReader builds a file reader with a proper user-agent.
// Unit tests should never make network call to the internet, but just in case we
// set the user-agent to be able to pin-point them here.
func NewFileReader() *files.Reader {
return files.NewReader(files.WithEKSAUserAgent("unit-test", "no-version"))
}
| 145 |
eks-anywhere | aws | Go | package test
import (
"errors"
"io"
"io/fs"
"os"
"testing"
"k8s.io/client-go/rest"
"sigs.k8s.io/controller-runtime/pkg/envtest"
)
// WithFakeFile returns a throwaway file in a test-specific directory.
//
// The file is automatically closed and removed when the test ends.
func WithFakeFile(t *testing.T) (f *os.File) {
f, err := os.CreateTemp(t.TempDir(), "fake-file")
if err != nil {
t.Fatalf("opening throwaway file: %s", err)
}
t.Cleanup(func() {
if err := f.Close(); err != nil {
t.Logf("closing throwaway file %q: %s", f.Name(), err)
}
})
return f
}
// WithFakeFileContents returns a throwaway file containing some data.
//
// The file is automatically closed and removed when the test ends.
func WithFakeFileContents(t *testing.T, r io.Reader) (f *os.File) {
f = WithFakeFile(t)
_, err := io.Copy(f, r)
if err != nil {
t.Fatalf("copying contents into fake file %q: %s", f.Name(), err)
}
return f
}
// RemoveFileIfExists is a helper for ValidateFilename tests.
func RemoveFileIfExists(t *testing.T, filename string) {
if err := os.Remove(filename); err != nil {
if !errors.Is(err, fs.ErrNotExist) {
t.Fatalf("removing file %q: %s", filename, err)
}
}
}
// UseEnvTest sets up the controller-runtime EnvTest framework.
//
// The test will be skipped if EnvTest framework isn't detected.
//
// EnvTest provides fake k8s control plane components for testing
// purposes. The process of bringing up and tearing down the EnvTest framework
// involves running a few binaries, and is not integrated into a vanilla "go
// test" run, but rather can be run via the unit-test target in Makefile. See
// https://book.kubebuilder.io/reference/envtest.html for details.
//
// TODO: What could be done to integrate EnvTest with go test, so that "go
// test" would work?
func UseEnvTest(t *testing.T) *rest.Config {
// Detect if EnvTest has been set up.
if os.Getenv("KUBEBUILDER_ASSETS") == "" {
// By skipping this test, we allow traditional runs of go test from
// the command-line (or your editor) to work.
t.Skip("no EnvTest assets found in KUBEBUILDER_ASSETS")
}
testEnv := &envtest.Environment{}
cfg, err := testEnv.Start()
if err != nil {
t.Fatalf("setting up EnvTest framework: %s", err)
}
t.Cleanup(func() {
if err := testEnv.Stop(); err != nil {
t.Logf("stopping EnvTest framework: %s", err)
}
})
return cfg
}
| 87 |
eks-anywhere | aws | Go | package test
import (
"net/http"
"net/http/httptest"
"os"
"testing"
)
func NewHTTPServerForFile(t *testing.T, filePath string) *httptest.Server {
fileContent, err := os.ReadFile(filePath)
if err != nil {
t.Fatalf("Failed reading file [%s] to serve from http: %s", filePath, err)
}
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if _, err := w.Write(fileContent); err != nil {
t.Errorf("Failed writing response to http request: %s", err)
}
}))
t.Cleanup(func() { ts.Close() })
return ts
}
// NewHTTPSServerForFile creates an HTTPS server that always serves the content of the
// given file.
func NewHTTPSServerForFile(t *testing.T, filePath string) *httptest.Server {
fileContent, err := os.ReadFile(filePath)
if err != nil {
t.Fatalf("Failed reading file [%s] to serve from http: %s", filePath, err)
}
ts := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if _, err := w.Write(fileContent); err != nil {
t.Errorf("Failed writing response to http request: %s", err)
}
}))
t.Cleanup(func() { ts.Close() })
return ts
}
| 39 |
eks-anywhere | aws | Go | package test
import (
"k8s.io/apimachinery/pkg/runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/client/fake"
_ "github.com/aws/eks-anywhere/internal/test/envtest"
"github.com/aws/eks-anywhere/pkg/clients/kubernetes"
"github.com/aws/eks-anywhere/pkg/controller/clientutil"
)
// NewKubeClient builds a new kubernetes.Client by using client.Client.
func NewKubeClient(client client.Client) kubernetes.Client {
return clientutil.NewKubeClient(client)
}
// NewFakeKubeClient returns a kubernetes.Client that uses a fake client.Client under the hood.
func NewFakeKubeClient(objs ...client.Object) kubernetes.Client {
return NewKubeClient(fake.NewClientBuilder().WithObjects(objs...).Build())
}
// NewFakeKubeClientAlwaysError returns a kubernetes.Client that will always fail in any operation
// This is achieved by injecting an empty Scheme, which will make the underlying client.Client
// incapable of determining the resource type for a particular client.Object.
func NewFakeKubeClientAlwaysError(objs ...client.Object) kubernetes.Client {
return NewKubeClient(
fake.NewClientBuilder().WithScheme(runtime.NewScheme()).WithObjects(objs...).Build(),
)
}
| 31 |
eks-anywhere | aws | Go | package test
// KubeVipTemplate is the default kube-vip pod template for internal testing.
const KubeVipTemplate = `apiVersion: v1
kind: Pod
metadata:
creationTimestamp: null
name: kube-vip
namespace: kube-system
spec:
containers:
- args:
- manager
env:
- name: vip_arp
value: "true"
- name: port
value: "6443"
- name: vip_cidr
value: "32"
- name: cp_enable
value: "true"
- name: cp_namespace
value: kube-system
- name: vip_ddns
value: "false"
- name: vip_leaderelection
value: "true"
- name: vip_leaseduration
value: "15"
- name: vip_renewdeadline
value: "10"
- name: vip_retryperiod
value: "2"
- name: address
value: 1.2.3.4
image: public.ecr.aws/l0g8r8j6/kube-vip/kube-vip:v0.3.7-eks-a-v0.0.0-dev-build.1433
imagePullPolicy: IfNotPresent
name: kube-vip
resources: {}
securityContext:
capabilities:
add:
- NET_ADMIN
- NET_RAW
volumeMounts:
- mountPath: /etc/kubernetes/admin.conf
name: kubeconfig
hostNetwork: true
volumes:
- hostPath:
path: /etc/kubernetes/admin.conf
name: kubeconfig
status: {}
`
| 56 |
eks-anywhere | aws | Go | package test
import (
"github.com/go-logr/logr"
"sigs.k8s.io/controller-runtime/pkg/log"
)
func NewNullLogger() logr.Logger {
return logr.New(log.NullLogSink{})
}
| 11 |
eks-anywhere | aws | Go | package test
import (
"context"
"fmt"
"reflect"
"github.com/golang/mock/gomock"
)
type ofType struct{ t string }
func OfType(t string) gomock.Matcher {
return &ofType{t}
}
func (o *ofType) Matches(x interface{}) bool {
return reflect.TypeOf(x).String() == o.t
}
func (o *ofType) String() string {
return "is of type " + o.t
}
// AContext returns a gomock matchers that evaluates if the receive value can
// fullfills the context.Context interface.
func AContext() gomock.Matcher {
ctxInterface := reflect.TypeOf((*context.Context)(nil)).Elem()
return gomock.AssignableToTypeOf(ctxInterface)
}
type bytesMatchFile struct{ file string }
// MatchFile returns a gomock matcher that compares []byte input to the content
// of the given file.
func MatchFile(file string) gomock.Matcher {
return &bytesMatchFile{file: file}
}
func (o *bytesMatchFile) Matches(x interface{}) bool {
content, ok := x.([]byte)
if !ok {
return false
}
equal, err := contentEqualToFile(content, o.file)
if err != nil {
return false
}
return equal
}
func (o *bytesMatchFile) String() string {
return "matches content of " + o.file
}
func (o *bytesMatchFile) Got(got interface{}) string {
content, ok := got.([]byte)
if !ok {
return "got is not a []byte"
}
diff, err := computeDiffBetweenContentAndFile(content, o.file)
if err != nil {
return fmt.Sprintf("failed computing diff with file %s: %s", o.file, err)
}
return fmt.Sprintf("is not equal to file %s:\n%s", o.file, diff)
}
| 71 |
eks-anywhere | aws | Go | package test
import "math/rand"
const alphanumeric = "abcdefghijklmnopqrstuvwxyz0123456789"
func RandString(n int) string {
b := make([]byte, n)
for i := range b {
b[i] = alphanumeric[rand.Intn(len(alphanumeric))]
}
return string(b)
}
| 14 |
eks-anywhere | aws | Go | package test
// Reader is a commonly used interface in multiple packages
// We are replicating here just to create a single mock we can
// use in multiple test packages.
type Reader interface {
ReadFile(url string) ([]byte, error)
}
| 9 |
eks-anywhere | aws | Go | package test
import (
bootstrapv1 "sigs.k8s.io/cluster-api/bootstrap/kubeadm/api/v1beta1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
)
// RegistryMirrorInsecureSkipVerifyEnabled returns a test RegistryMirrorConfiguration with InsecureSkipVerify enabled.
func RegistryMirrorInsecureSkipVerifyEnabled() *anywherev1.RegistryMirrorConfiguration {
return &anywherev1.RegistryMirrorConfiguration{
Endpoint: "0.0.0.0",
Port: "5000",
InsecureSkipVerify: true,
}
}
// RegistryMirrorInsecureSkipVerifyEnabledAndCACert returns a test RegistryMirrorConfiguration with a CACert specified and InsecureSkipVerify enabled.
func RegistryMirrorInsecureSkipVerifyEnabledAndCACert() *anywherev1.RegistryMirrorConfiguration {
return &anywherev1.RegistryMirrorConfiguration{
Endpoint: "0.0.0.0",
Port: "5000",
InsecureSkipVerify: true,
CACertContent: CACertContent(),
}
}
// CACertContent returns a test string representing a cacert contents.
func CACertContent() string {
return `-----BEGIN CERTIFICATE-----
8wHMSjm0Mzf0VtaqLcoNXEYv3rWB08wydabTAxSAlFMmDJbFyXmI1tYgeps0n/Mt
7dvC9zcJkTibFw8YdV5TTlo3aZYYaUiAsFOLhPB41JA4hOtCgrN38Uj3R7pniAlq
u55B9FjSOOMaooBo+vzdhG/AZD9A2qohos4C7azLjWnTunqjEh0PC0QLZ6oE76jw
xTAY4N4C2s/wIybZxaJ8iQ39OzDpyN2Ym40Q58GVOHt16XCjFVVorVcZsI3y2B9Q
9iV7x+Ulu9jtvZ1K54Uspx6dq4K3
-----END CERTIFICATE-----
`
}
// RegistryMirrorConfigFilesInsecureSkipVerify returns cluster-api bootstrap files that configure containerd
// to use a registry mirror with the insecure_skip_verify flag enabled.
func RegistryMirrorConfigFilesInsecureSkipVerify() []bootstrapv1.File {
return []bootstrapv1.File{
{
Content: `[plugins."io.containerd.grpc.v1.cri".registry.mirrors]
[plugins."io.containerd.grpc.v1.cri".registry.mirrors."public.ecr.aws"]
endpoint = ["https://0.0.0.0:5000"]
[plugins."io.containerd.grpc.v1.cri".registry.configs."0.0.0.0:5000".tls]
insecure_skip_verify = true
`,
Owner: "root:root",
Path: "/etc/containerd/config_append.toml",
},
}
}
// RegistryMirrorConfigFilesInsecureSkipVerifyAndCACert returns cluster-api bootstrap files that configure containerd
// to use a registry mirror with a cacert file and insecure_skip_verify flag enabled.
func RegistryMirrorConfigFilesInsecureSkipVerifyAndCACert() []bootstrapv1.File {
return []bootstrapv1.File{
{
Content: CACertContent(),
Owner: "root:root",
Path: "/etc/containerd/certs.d/0.0.0.0:5000/ca.crt",
},
{
Content: `[plugins."io.containerd.grpc.v1.cri".registry.mirrors]
[plugins."io.containerd.grpc.v1.cri".registry.mirrors."public.ecr.aws"]
endpoint = ["https://0.0.0.0:5000"]
[plugins."io.containerd.grpc.v1.cri".registry.configs."0.0.0.0:5000".tls]
ca_file = "/etc/containerd/certs.d/0.0.0.0:5000/ca.crt"
insecure_skip_verify = true
`,
Owner: "root:root",
Path: "/etc/containerd/config_append.toml",
},
}
}
// RegistryMirrorPreKubeadmCommands returns a list of commands to writes a config_append.toml file
// to configure the registry mirror and restart containerd.
func RegistryMirrorPreKubeadmCommands() []string {
return []string{
"cat /etc/containerd/config_append.toml >> /etc/containerd/config.toml",
"systemctl daemon-reload",
"systemctl restart containerd",
}
}
// RegistryMirrorSudoPreKubeadmCommands returns a list of commands that writes a config_append.toml file
// to configure the registry mirror and restart containerd with sudo permissions.
func RegistryMirrorSudoPreKubeadmCommands() []string {
return []string{
"cat /etc/containerd/config_append.toml >> /etc/containerd/config.toml",
"sudo systemctl daemon-reload",
"sudo systemctl restart containerd",
}
}
| 99 |
eks-anywhere | aws | Go | package test
import (
"time"
eksdv1 "github.com/aws/eks-distro-build-tooling/release/api/v1alpha1"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
controlplanev1 "sigs.k8s.io/cluster-api/controlplane/kubeadm/api/v1beta1"
anywherev1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/clusterapi"
"github.com/aws/eks-anywhere/pkg/constants"
releasev1 "github.com/aws/eks-anywhere/release/api/v1alpha1"
)
// Namespace returns a test namespace struct for unit testing.
func Namespace(name string) *corev1.Namespace {
return &corev1.Namespace{
TypeMeta: metav1.TypeMeta{
Kind: "Namespace",
APIVersion: "v1",
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
},
}
}
// EksdRelease returns a test release struct for unit testing.
func EksdRelease() *eksdv1.Release {
return &eksdv1.Release{
TypeMeta: metav1.TypeMeta{
Kind: "Release",
APIVersion: "distro.eks.amazonaws.com/v1alpha1",
},
ObjectMeta: metav1.ObjectMeta{
Name: "test",
Namespace: "eksa-system",
},
Spec: eksdv1.ReleaseSpec{
Number: 1,
},
Status: eksdv1.ReleaseStatus{
Components: []eksdv1.Component{
{
Assets: []eksdv1.Asset{
{
Name: "etcd-image",
Image: &eksdv1.AssetImage{},
},
{
Name: "node-driver-registrar-image",
Image: &eksdv1.AssetImage{},
},
{
Name: "livenessprobe-image",
Image: &eksdv1.AssetImage{},
},
{
Name: "external-attacher-image",
Image: &eksdv1.AssetImage{},
},
{
Name: "external-provisioner-image",
Image: &eksdv1.AssetImage{},
},
{
Name: "pause-image",
Image: &eksdv1.AssetImage{},
},
{
Name: "aws-iam-authenticator-image",
Image: &eksdv1.AssetImage{},
},
{
Name: "coredns-image",
Image: &eksdv1.AssetImage{},
},
{
Name: "kube-apiserver-image",
Image: &eksdv1.AssetImage{
URI: "public.ecr.aws/eks-distro/kubernetes/kube-apiserver:v1.19.8",
},
},
{
Name: "kube-proxy-image",
Image: &eksdv1.AssetImage{
URI: "public.ecr.aws/eks-distro/kubernetes/kube-proxy:v1.19.8-eks-1-19-18",
},
},
},
},
},
},
}
}
// Bundle returns a test bundle struct for unit testing.
func Bundle() *releasev1.Bundles {
return &releasev1.Bundles{
TypeMeta: metav1.TypeMeta{
Kind: "Bundles",
APIVersion: releasev1.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: "bundles-1",
Namespace: "default",
},
Spec: releasev1.BundlesSpec{
VersionsBundles: []releasev1.VersionsBundle{
{
KubeVersion: "1.22",
EksD: releasev1.EksDRelease{
Name: "test",
EksDReleaseUrl: "testdata/release.yaml",
KubeVersion: "1.22",
},
CertManager: releasev1.CertManagerBundle{},
ClusterAPI: releasev1.CoreClusterAPI{},
Bootstrap: releasev1.KubeadmBootstrapBundle{},
ControlPlane: releasev1.KubeadmControlPlaneBundle{},
VSphere: releasev1.VSphereBundle{},
Docker: releasev1.DockerBundle{},
Eksa: releasev1.EksaBundle{},
Cilium: releasev1.CiliumBundle{},
Kindnetd: releasev1.KindnetdBundle{},
Flux: releasev1.FluxBundle{},
BottleRocketHostContainers: releasev1.BottlerocketHostContainersBundle{},
ExternalEtcdBootstrap: releasev1.EtcdadmBootstrapBundle{},
ExternalEtcdController: releasev1.EtcdadmControllerBundle{},
Tinkerbell: releasev1.TinkerbellBundle{},
},
},
},
}
}
// CAPIClusterOpt represents an function where a capi cluster is passed as an argument.
type CAPIClusterOpt func(*clusterv1.Cluster)
// CAPICluster returns a capi cluster which can be configured by passing in opts arguments.
func CAPICluster(opts ...CAPIClusterOpt) *clusterv1.Cluster {
c := &clusterv1.Cluster{
TypeMeta: metav1.TypeMeta{
Kind: anywherev1.ClusterKind,
APIVersion: clusterv1.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Namespace: constants.EksaSystemNamespace,
},
Status: clusterv1.ClusterStatus{
Conditions: clusterv1.Conditions{
{
Type: clusterapi.ControlPlaneReadyCondition,
Status: corev1.ConditionTrue,
LastTransitionTime: metav1.NewTime(time.Now()),
},
},
},
}
for _, opt := range opts {
opt(c)
}
return c
}
// KubeadmControlPlaneOpt represents an function where a kubeadmcontrolplane is passed as an argument.
type KubeadmControlPlaneOpt func(kcp *controlplanev1.KubeadmControlPlane)
// KubeadmControlPlane returns a kubeadm controlplane which can be configured by passing in opts arguments.
func KubeadmControlPlane(opts ...KubeadmControlPlaneOpt) *controlplanev1.KubeadmControlPlane {
kcp := &controlplanev1.KubeadmControlPlane{
TypeMeta: metav1.TypeMeta{
Kind: "KubeadmControlPlane",
APIVersion: controlplanev1.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Namespace: constants.EksaSystemNamespace,
},
}
for _, opt := range opts {
opt(kcp)
}
return kcp
}
// MachineDeploymentOpt represents an function where a kubeadmcontrolplane is passed as an argument.
type MachineDeploymentOpt func(md *clusterv1.MachineDeployment)
// MachineDeployment returns a machinedeployment which can be configured by passing in opts arguments.
func MachineDeployment(opts ...MachineDeploymentOpt) *clusterv1.MachineDeployment {
md := &clusterv1.MachineDeployment{
TypeMeta: metav1.TypeMeta{
Kind: "MachineDeployment",
APIVersion: clusterv1.GroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Namespace: constants.EksaSystemNamespace,
},
}
for _, opt := range opts {
opt(md)
}
return md
}
| 214 |
eks-anywhere | aws | Go | package test
import "time"
var (
defaultNow = time.Unix(0, 1234567890000*int64(time.Millisecond))
newNow = time.Unix(0, 987654321000*int64(time.Millisecond))
)
func FakeNow() time.Time {
return defaultNow
}
// NewFakeNow sets a dummy value for time.Now in unit tests.
// This is particularly useful when testing upgrade operations.
func NewFakeNow() time.Time {
return newNow
}
| 19 |
eks-anywhere | aws | Go | package cleanup
import (
"context"
"fmt"
"strconv"
"time"
"github.com/aws/aws-sdk-go/aws/session"
prismgoclient "github.com/nutanix-cloud-native/prism-go-client"
v3 "github.com/nutanix-cloud-native/prism-go-client/v3"
"github.com/aws/eks-anywhere/internal/pkg/ec2"
"github.com/aws/eks-anywhere/internal/pkg/s3"
"github.com/aws/eks-anywhere/pkg/executables"
"github.com/aws/eks-anywhere/pkg/filewriter"
"github.com/aws/eks-anywhere/pkg/logger"
"github.com/aws/eks-anywhere/pkg/providers/cloudstack/decoder"
"github.com/aws/eks-anywhere/pkg/providers/nutanix"
"github.com/aws/eks-anywhere/pkg/retrier"
"github.com/aws/eks-anywhere/pkg/validations"
)
const (
cleanupRetries = 5
retryBackoff = 10 * time.Second
)
func CleanUpAwsTestResources(storageBucket string, maxAge string, tag string) error {
session, err := session.NewSession()
if err != nil {
return fmt.Errorf("creating session: %v", err)
}
logger.V(1).Info("Fetching list of EC2 instances")
key := "Integration-Test"
value := tag
maxAgeFloat, err := strconv.ParseFloat(maxAge, 64)
if err != nil {
return fmt.Errorf("parsing max age: %v", err)
}
results, err := ec2.ListInstances(session, key, value, maxAgeFloat)
if err != nil {
return fmt.Errorf("listing EC2 instances: %v", err)
}
logger.V(1).Info("Successfully listed EC2 instances for termination")
if len(results) != 0 {
logger.V(1).Info("Terminating EC2 instances")
err = ec2.TerminateEc2Instances(session, results)
if err != nil {
return fmt.Errorf("terminating EC2 instacnes: %v", err)
}
logger.V(1).Info("Successfully terminated EC2 instances")
} else {
logger.V(1).Info("No EC2 instances available for termination")
}
logger.V(1).Info("Clean up s3 bucket objects")
s3MaxAge := "604800" // one week
s3MaxAgeFloat, err := strconv.ParseFloat(s3MaxAge, 64)
if err != nil {
return fmt.Errorf("parsing S3 max age: %v", err)
}
err = s3.CleanUpS3Bucket(session, storageBucket, s3MaxAgeFloat)
if err != nil {
return fmt.Errorf("clean up s3 bucket objects: %v", err)
}
logger.V(1).Info("Successfully cleaned up s3 bucket")
return nil
}
func CleanUpVsphereTestResources(ctx context.Context, clusterName string) error {
clusterName, err := validations.ValidateClusterNameArg([]string{clusterName})
if err != nil {
return fmt.Errorf("validating cluster name: %v", err)
}
err = VsphereRmVms(ctx, clusterName)
if err != nil {
return fmt.Errorf("removing vcenter vms: %v", err)
}
logger.V(1).Info("Vsphere vcenter vms cleanup complete")
return nil
}
func VsphereRmVms(ctx context.Context, clusterName string, opts ...executables.GovcOpt) error {
logger.V(1).Info("Deleting vsphere vcenter vms")
executableBuilder, close, err := executables.InitInDockerExecutablesBuilder(ctx, executables.DefaultEksaImage())
if err != nil {
return fmt.Errorf("unable to initialize executables: %v", err)
}
defer close.CheckErr(ctx)
tmpWriter, _ := filewriter.NewWriter("rmvms")
govc := executableBuilder.BuildGovcExecutable(tmpWriter, opts...)
defer govc.Close(ctx)
return govc.CleanupVms(ctx, clusterName, false)
}
func CleanUpCloudstackTestResources(ctx context.Context, clusterName string, dryRun bool) error {
executableBuilder, close, err := executables.InitInDockerExecutablesBuilder(ctx, executables.DefaultEksaImage())
if err != nil {
return fmt.Errorf("unable to initialize executables: %v", err)
}
defer close.CheckErr(ctx)
tmpWriter, err := filewriter.NewWriter("rmvms")
if err != nil {
return fmt.Errorf("creating filewriter for directory rmvms: %v", err)
}
execConfig, err := decoder.ParseCloudStackCredsFromEnv()
if err != nil {
return fmt.Errorf("parsing cloudstack credentials from environment: %v", err)
}
cmk, err := executableBuilder.BuildCmkExecutable(tmpWriter, execConfig)
if err != nil {
return fmt.Errorf("building cmk executable: %v", err)
}
defer cmk.Close(ctx)
cleanupRetrier := retrier.NewWithMaxRetries(cleanupRetries, retryBackoff)
errorsMap := map[string]error{}
for _, profile := range execConfig.Profiles {
if err := cleanupRetrier.Retry(func() error {
return cmk.CleanupVms(ctx, profile.Name, clusterName, dryRun)
}); err != nil {
errorsMap[profile.Name] = err
}
}
if len(errorsMap) > 0 {
return fmt.Errorf("cleaning up VMs: %+v", errorsMap)
}
return nil
}
// NutanixTestResourcesCleanup cleans up any leftover VMs in Nutanix after a test run.
func NutanixTestResourcesCleanup(ctx context.Context, clusterName, endpoint, port string, insecure, ignoreErrors bool) error {
creds := nutanix.GetCredsFromEnv()
nutanixCreds := prismgoclient.Credentials{
URL: fmt.Sprintf("%s:%s", endpoint, port),
Username: creds.PrismCentral.Username,
Password: creds.PrismCentral.Password,
Endpoint: endpoint,
Port: port,
Insecure: insecure,
}
client, err := v3.NewV3Client(nutanixCreds)
if err != nil {
return fmt.Errorf("initailizing prism client: %v", err)
}
response, err := client.V3.ListAllVM(context.Background(), fmt.Sprintf("vm_name==%s.*", clusterName))
if err != nil {
return fmt.Errorf("getting ListVM response: %v", err)
}
for _, vm := range response.Entities {
logger.V(4).Info("Deleting Nutanix VM", "Name", *vm.Spec.Name, "UUID:", *vm.Metadata.UUID)
_, err = client.V3.DeleteVM(context.Background(), *vm.Metadata.UUID)
if err != nil {
if !ignoreErrors {
return fmt.Errorf("deleting Nutanix VM %s: %v", *vm.Spec.Name, err)
}
logger.Info("Warning: Failed to delete Nutanix VM, skipping...", "Name", *vm.Spec.Name, "UUID:", *vm.Metadata.UUID)
}
}
return nil
}
| 169 |
eks-anywhere | aws | Go | package e2e
import (
"fmt"
"path/filepath"
"github.com/go-logr/logr"
"github.com/aws/eks-anywhere/internal/pkg/s3"
"github.com/aws/eks-anywhere/internal/pkg/ssm"
)
const e2eHomeFolder = "/home/e2e/"
func (e *E2ESession) uploadGeneratedFilesFromInstance(testName string) {
e.logger.V(1).Info("Uploading log files to s3 bucket")
command := newCopyCommand().from(
e2eHomeFolder, e.clusterName(e.branchName, e.instanceId, testName),
).to(
e.generatedArtifactsBucketPath(), testName,
).recursive().String()
if err := ssm.Run(e.session, logr.Discard(), e.instanceId, command, ssmTimeout); err != nil {
e.logger.Error(err, "error uploading log files from instance")
} else {
e.logger.V(1).Info("Successfully uploaded log files to S3")
}
}
func (e *E2ESession) uploadDiagnosticArchiveFromInstance(testName string) {
bundleNameFormat := "support-bundle-*.tar.gz"
e.logger.V(1).Info("Uploading diagnostic bundle to s3 bucket")
command := newCopyCommand().from(e2eHomeFolder).to(
e.generatedArtifactsBucketPath(), testName,
).recursive().exclude("*").include(bundleNameFormat).String()
if err := ssm.Run(e.session, logr.Discard(), e.instanceId, command, ssmTimeout); err != nil {
e.logger.Error(err, "error uploading diagnostic bundle from instance")
} else {
e.logger.V(1).Info("Successfully uploaded diagnostic bundle files to S3")
}
}
func (e *E2ESession) uploadJUnitReportFromInstance(testName string) {
junitFile := "junit-testing.xml"
e.logger.V(1).Info("Uploading JUnit report to s3 bucket")
command := newCopyCommand().from(e2eHomeFolder).to(
e.generatedArtifactsBucketPath(), testName,
).recursive().exclude("*").include(junitFile).String()
if err := ssm.Run(e.session, logr.Discard(), e.instanceId, command, ssmTimeout); err != nil {
e.logger.Error(err, "error uploading JUnit report from instance")
} else {
e.logger.V(1).Info("Successfully uploaded JUnit report files to S3")
}
}
func (e *E2ESession) downloadJUnitReportToLocalDisk(testName, destinationFolder string) {
junitFile := "junit-testing.xml"
key := filepath.Join(e.generatedArtifactsPath(), testName, junitFile)
dst := filepath.Join(destinationFolder, fmt.Sprintf("junit-testing-%s.xml", testName))
e.logger.V(1).Info("Downloading JUnit report to disk", "dst", dst)
if err := s3.DownloadToDisk(e.session, key, e.storageBucket, dst); err != nil {
e.logger.Error(err, "Error downloading JUnit report from s3")
}
}
func (e *E2ESession) generatedArtifactsBucketPath() string {
return fmt.Sprintf("s3://%s/%s", e.storageBucket, e.generatedArtifactsPath())
}
func (e *E2ESession) generatedArtifactsPath() string {
return filepath.Join(e.jobId, "generated-artifacts")
}
| 76 |
eks-anywhere | aws | Go | package e2e
import (
"os"
"regexp"
e2etests "github.com/aws/eks-anywhere/test/framework"
)
func (e *E2ESession) setupAwsIam(testRegex string) error {
re := regexp.MustCompile(`^.*AWSIamAuth.*$`)
if !re.MatchString(testRegex) {
return nil
}
requiredEnvVars := e2etests.RequiredAWSIamEnvVars()
for _, eVar := range requiredEnvVars {
if val, ok := os.LookupEnv(eVar); ok {
e.testEnvVars[eVar] = val
}
}
return nil
}
| 25 |
eks-anywhere | aws | Go | package e2e
import (
"os"
"regexp"
e2etests "github.com/aws/eks-anywhere/test/framework"
)
const (
cloudstackRegex = `^.*CloudStack.*$`
)
func (e *E2ESession) setupCloudStackEnv(testRegex string) error {
re := regexp.MustCompile(cloudstackRegex)
if !re.MatchString(testRegex) {
return nil
}
requiredEnvVars := e2etests.RequiredCloudstackEnvVars()
for _, eVar := range requiredEnvVars {
if val, ok := os.LookupEnv(eVar); ok {
e.testEnvVars[eVar] = val
}
}
return nil
}
| 28 |
eks-anywhere | aws | Go | package e2e
import (
"fmt"
"strings"
)
type copyCommand string
func newCopyCommand() copyCommand {
return "aws s3 cp"
}
func (c copyCommand) String() string {
return string(c)
}
func (c copyCommand) addOption(opt string) copyCommand {
return copyCommand(fmt.Sprintf("%s %s", string(c), opt))
}
func (c copyCommand) from(p ...string) copyCommand {
return c.addOption(strings.Join(p, "/"))
}
func (c copyCommand) to(p ...string) copyCommand {
return c.addOption(strings.Join(p, "/"))
}
func (c copyCommand) recursive() copyCommand {
return c.addOption("--recursive")
}
func (c copyCommand) exclude(v string) copyCommand {
return c.addOption(fmt.Sprintf("--exclude \"%s\"", v))
}
func (c copyCommand) include(v string) copyCommand {
return c.addOption(fmt.Sprintf("--include \"%s\"", v))
}
| 41 |
eks-anywhere | aws | Go | package e2e
import (
"testing"
. "github.com/onsi/gomega"
)
func TestCopyCommand(t *testing.T) {
tests := []struct {
name string
c copyCommand
want string
}{
{
name: "simple upload",
c: newCopyCommand().from(
"/home/path", "user",
).to("s3://bucket", "path"),
want: "aws s3 cp /home/path/user s3://bucket/path",
},
{
name: "simple download",
c: newCopyCommand().from(
"s3://bucket", "path",
).to("/home/path", "user"),
want: "aws s3 cp s3://bucket/path /home/path/user",
},
{
name: "recursive upload exclude everything include file pattern",
c: newCopyCommand().from("/home/e2e/").to(
"s3://bucket", "path", "path2/",
).recursive().exclude("*").include("support-bundle-*.tar.gz"),
want: "aws s3 cp /home/e2e/ s3://bucket/path/path2/ --recursive --exclude \"*\" --include \"support-bundle-*.tar.gz\"",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
g := NewWithT(t)
g.Expect(tt.c.String()).To(Equal(tt.want), "String() should return the proper built s3 copy command")
})
}
}
| 44 |
eks-anywhere | aws | Go | package e2e
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
"encoding/pem"
"fmt"
"golang.org/x/crypto/ssh"
)
func generateKeyPairEcdsa() (*ecdsa.PrivateKey, error) {
k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, fmt.Errorf("generating key pair: %v", err)
}
return k, nil
}
func pubFromPrivateKeyEcdsa(k *ecdsa.PrivateKey) ([]byte, error) {
pub, err := ssh.NewPublicKey(k.Public())
if err != nil {
return nil, err
}
return ssh.MarshalAuthorizedKey(pub), nil
}
func pemFromPrivateKeyEcdsa(k *ecdsa.PrivateKey) ([]byte, error) {
pk, err := x509.MarshalPKCS8PrivateKey(k)
if err != nil {
return nil, fmt.Errorf("marshalling private key to x509 PKCS 8 from private key: %v", err)
}
p := pem.Block{
Type: "PRIVATE KEY",
Bytes: pk,
}
return pem.EncodeToMemory(&p), nil
}
| 43 |
eks-anywhere | aws | Go | package e2e
import (
"os"
"regexp"
e2etests "github.com/aws/eks-anywhere/test/framework"
)
func (e *E2ESession) setupFluxEnv(testRegex string) error {
re := regexp.MustCompile(`^.*Flux.*$`)
if !re.MatchString(testRegex) {
return nil
}
requiredEnvVars := e2etests.RequiredFluxGithubEnvVars()
for _, eVar := range requiredEnvVars {
if val, ok := os.LookupEnv(eVar); ok {
e.testEnvVars[eVar] = val
}
}
return nil
}
| 24 |
eks-anywhere | aws | Go | package e2e
import (
"context"
"encoding/base64"
"fmt"
"log"
"os"
"regexp"
"strings"
"time"
"github.com/go-logr/logr"
"github.com/aws/eks-anywhere/internal/pkg/ssm"
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/config"
"github.com/aws/eks-anywhere/pkg/git"
"github.com/aws/eks-anywhere/pkg/retrier"
e2etests "github.com/aws/eks-anywhere/test/framework"
)
type s3Files struct {
key, dstPath string
permission int
}
type fileFromBytes struct {
dstPath string
permission int
content []byte
}
func (f *fileFromBytes) contentString() string {
return string(f.content)
}
func (e *E2ESession) setupFluxGitEnv(testRegex string) error {
re := regexp.MustCompile(`^.*GitFlux.*$`)
if !re.MatchString(testRegex) {
return nil
}
requiredEnvVars := e2etests.RequiredFluxGitCreateRepoEnvVars()
for _, eVar := range requiredEnvVars {
if val, ok := os.LookupEnv(eVar); ok {
e.testEnvVars[eVar] = val
}
}
repo, err := e.setupGithubRepo()
if err != nil {
return fmt.Errorf("setting up github repo for test: %v", err)
}
// add the newly generated repository to the test
e.testEnvVars[e2etests.GitRepoSshUrl] = gitRepoSshUrl(repo.Name, e.testEnvVars[e2etests.GithubUserVar])
for _, file := range buildFluxGitFiles(e.testEnvVars) {
if err := e.downloadFileInInstance(file); err != nil {
return fmt.Errorf("downloading flux-git file to instance: %v", err)
}
}
err = e.setUpSshAgent(e.testEnvVars[config.EksaGitPrivateKeyTokenEnv])
if err != nil {
return fmt.Errorf("setting up ssh agent on remote instance: %v", err)
}
return nil
}
func buildFluxGitFiles(envVars map[string]string) []s3Files {
return []s3Files{
{
key: "git-flux/known_hosts",
dstPath: envVars[config.EksaGitKnownHostsFileEnv],
permission: 644,
},
}
}
func (e *E2ESession) decodeAndWriteFileToInstance(file fileFromBytes) error {
e.logger.V(1).Info("Writing bytes to file in instance", "file", file.dstPath)
command := fmt.Sprintf("echo '%s' | base64 -d >> %s && chmod %d %[2]s", file.contentString(), file.dstPath, file.permission)
if err := ssm.Run(e.session, logr.Discard(), e.instanceId, command, ssmTimeout); err != nil {
return fmt.Errorf("writing file in instance: %v", err)
}
e.logger.V(1).Info("Successfully decoded and wrote file", "file", file.dstPath)
return nil
}
func (e *E2ESession) downloadFileInInstance(file s3Files) error {
e.logger.V(1).Info("Downloading from s3 in instance", "file", file.key)
command := fmt.Sprintf("aws s3 cp s3://%s/%s %s && chmod %d %[3]s", e.storageBucket, file.key, file.dstPath, file.permission)
if err := ssm.Run(e.session, logr.Discard(), e.instanceId, command, ssmTimeout); err != nil {
return fmt.Errorf("downloading file in instance: %v", err)
}
e.logger.V(1).Info("Successfully downloaded file", "file", file.key)
return nil
}
func (e *E2ESession) setUpSshAgent(privateKeyFile string) error {
command := fmt.Sprintf("eval $(ssh-agent -s) ssh-add %s", privateKeyFile)
if err := ssm.Run(e.session, logr.Discard(), e.instanceId, command, ssmTimeout); err != nil {
return fmt.Errorf("starting SSH agent on instance: %v", err)
}
e.logger.V(1).Info("Successfully started SSH agent on instance")
return nil
}
func (e *E2ESession) setupGithubRepo() (*git.Repository, error) {
e.logger.V(1).Info("setting up Github repo for test")
owner := e.testEnvVars[e2etests.GithubUserVar]
repo := strings.ReplaceAll(e.jobId, ":", "-") // Github API urls get funky if you use ":" in the repo name
c := &v1alpha1.GithubProviderConfig{
Owner: owner,
Repository: repo,
Personal: true,
}
ctx := context.Background()
g, err := e.TestGithubClient(ctx, e.testEnvVars[e2etests.GithubTokenVar], c.Owner, c.Repository, c.Personal)
if err != nil {
return nil, fmt.Errorf("couldn't create Github client for test setup: %v", err)
}
// Create a new github repository for the tests to run on
o := git.CreateRepoOpts{
Name: repo,
Owner: owner,
Description: fmt.Sprintf("repository for use with E2E test job %v", e.jobId),
Personal: true,
AutoInit: true,
}
r, err := g.CreateRepo(ctx, o)
if err != nil {
return nil, fmt.Errorf("creating repository in Github for test: %v", err)
}
pk, pub, err := e.generateKeyPairForGitTest()
if err != nil {
return nil, fmt.Errorf("generating key pair for git tests: %v", err)
}
e.logger.Info("Create Deploy Key Configuration for Git Flux tests", "owner", owner, "repo", repo)
// Add the newly generated public key to the newly created repository as a deploy key
ko := git.AddDeployKeyOpts{
Owner: owner,
Repository: repo,
Key: string(pub),
Title: fmt.Sprintf("Test key created for job %v", e.jobId),
ReadOnly: false,
}
// Newly generated repositories may take some time to show up in the GitHub API; retry a few times to get around this
err = retrier.Retry(10, time.Second*10, func() error {
err = g.AddDeployKeyToRepo(ctx, ko)
if err != nil {
return fmt.Errorf("couldn't add deploy key to repo: %v", err)
}
return nil
})
if err != nil {
return r, err
}
encodedPK := encodePrivateKey(pk)
// Generate a PEM file from the private key and write it instance at the user-provided path
pkFile := fileFromBytes{
dstPath: e.testEnvVars[config.EksaGitPrivateKeyTokenEnv],
permission: 600,
content: encodedPK,
}
err = e.decodeAndWriteFileToInstance(pkFile)
if err != nil {
return nil, fmt.Errorf("writing private key file to instance: %v", err)
}
return r, err
}
func encodePrivateKey(privateKey []byte) []byte {
b64EncodedPK := make([]byte, base64.StdEncoding.EncodedLen(len(privateKey)))
base64.StdEncoding.Encode(b64EncodedPK, privateKey)
return b64EncodedPK
}
func (e *E2ESession) generateKeyPairForGitTest() (privateKeyBytes, publicKeyBytes []byte, err error) {
k, err := generateKeyPairEcdsa()
if err != nil {
return nil, nil, err
}
privateKeyBytes, err = pemFromPrivateKeyEcdsa(k)
if err != nil {
return nil, nil, err
}
publicKeyBytes, err = pubFromPrivateKeyEcdsa(k)
if err != nil {
return nil, nil, err
}
log.Println("Public key generated")
return privateKeyBytes, publicKeyBytes, nil
}
func gitRepoSshUrl(repo, owner string) string {
t := "ssh://[email protected]/%s/%s.git"
return fmt.Sprintf(t, owner, repo)
}
| 221 |
eks-anywhere | aws | Go | package e2e
import (
"context"
"fmt"
"github.com/aws/eks-anywhere/pkg/api/v1alpha1"
"github.com/aws/eks-anywhere/pkg/git"
"github.com/aws/eks-anywhere/pkg/git/gogithub"
"github.com/aws/eks-anywhere/pkg/git/providers/github"
)
func (e *E2ESession) TestGithubClient(ctx context.Context, githubToken string, owner string, repository string, personal bool) (git.ProviderClient, error) {
auth := git.TokenAuth{Token: githubToken, Username: owner}
gogithubOpts := gogithub.Options{Auth: auth}
githubProviderClient := gogithub.New(ctx, gogithubOpts)
config := &v1alpha1.GithubProviderConfig{
Owner: owner,
Repository: repository,
Personal: personal,
}
provider, err := github.New(githubProviderClient, config, auth)
if err != nil {
return nil, fmt.Errorf("creating test git provider: %v", err)
}
return provider, nil
}
| 30 |
eks-anywhere | aws | Go | package e2e
import (
"os"
"regexp"
e2etests "github.com/aws/eks-anywhere/test/framework"
)
func (e *E2ESession) setupNTPEnv(testRegex string) error {
re := regexp.MustCompile(`^.*NTP.*$`)
if !re.MatchString(testRegex) {
return nil
}
for _, eVar := range e2etests.RequiredNTPServersEnvVars() {
if val, ok := os.LookupEnv(eVar); ok {
e.testEnvVars[eVar] = val
}
}
return nil
}
func (e *E2ESession) setupBottlerocketKubernetesSettingsEnv(testRegex string) error {
re := regexp.MustCompile(`^.*BottlerocketKubernetesSettings.*$`)
if !re.MatchString(testRegex) {
return nil
}
for _, eVar := range e2etests.RequiredBottlerocketKubernetesSettingsEnvVars() {
if val, ok := os.LookupEnv(eVar); ok {
e.testEnvVars[eVar] = val
}
}
return nil
}
| 37 |
eks-anywhere | aws | Go | package e2e
import (
"github.com/go-logr/logr"
"github.com/aws/eks-anywhere/pkg/networkutils"
)
type E2EIPManager struct {
networkCidr string
networkIPs map[string]bool
logger logr.Logger
}
func newE2EIPManager(logger logr.Logger, networkCidr string) *E2EIPManager {
return &E2EIPManager{
networkCidr: networkCidr,
networkIPs: make(map[string]bool),
logger: logger,
}
}
func (ipman *E2EIPManager) reserveIP() string {
return ipman.getUniqueIP(ipman.networkCidr, ipman.networkIPs)
}
func (ipman *E2EIPManager) reserveIPPool(count int) networkutils.IPPool {
pool := networkutils.NewIPPool()
for i := 0; i < count; i++ {
pool.AddIP(ipman.reserveIP())
}
return pool
}
func (ipman *E2EIPManager) getUniqueIP(cidr string, usedIPs map[string]bool) string {
ipgen := networkutils.NewIPGenerator(&networkutils.DefaultNetClient{})
ip, err := ipgen.GenerateUniqueIP(cidr)
for ; err != nil || usedIPs[ip]; ip, err = ipgen.GenerateUniqueIP(cidr) {
if err != nil {
ipman.logger.V(2).Info("Warning: getting unique IP failed", "error", err)
}
if usedIPs[ip] {
ipman.logger.V(2).Info("Warning: generated IP is already taken", "IP", ip)
}
}
usedIPs[ip] = true
return ip
}
| 49 |
eks-anywhere | aws | Go | package e2e
import (
"bufio"
"context"
"fmt"
"path/filepath"
"strings"
"github.com/aws/eks-anywhere/pkg/executables"
"github.com/aws/eks-anywhere/pkg/types"
)
func listTests(regex string, testsToSkip []string) (tests, skippedTests []string, err error) {
e := executables.NewExecutable(filepath.Join("bin", e2eBinary))
ctx := context.Background()
testResponse, err := e.Execute(ctx, "-test.list", regex)
if err != nil {
return nil, nil, fmt.Errorf("failed listing test from e2e binary: %v", err)
}
skipLookup := types.SliceToLookup(testsToSkip)
scanner := bufio.NewScanner(&testResponse)
for scanner.Scan() {
line := scanner.Text()
if skipLookup.IsPresent(line) {
skippedTests = append(skippedTests, line)
continue
}
if strings.HasPrefix(line, "Test") {
tests = append(tests, line)
}
}
if err := scanner.Err(); err != nil {
return nil, nil, fmt.Errorf("failed reading e2e list response: %v", err)
}
return tests, skippedTests, nil
}
| 42 |
eks-anywhere | aws | Go | package e2e
import (
"os"
"regexp"
e2etests "github.com/aws/eks-anywhere/test/framework"
)
const (
nutanixCidrVar = "T_NUTANIX_CONTROL_PLANE_CIDR"
nutanixRegex = `^.*Nutanix.*$`
)
func (e *E2ESession) setupNutanixEnv(testRegex string) error {
re := regexp.MustCompile(nutanixRegex)
if !re.MatchString(testRegex) {
return nil
}
requiredEnvVars := e2etests.RequiredNutanixEnvVars()
for _, eVar := range requiredEnvVars {
if val, ok := os.LookupEnv(eVar); ok {
e.testEnvVars[eVar] = val
}
}
return nil
}
| 30 |
eks-anywhere | aws | Go | package e2e
import (
"fmt"
"path/filepath"
"regexp"
"github.com/go-logr/logr"
"github.com/aws/eks-anywhere/internal/pkg/oidc"
"github.com/aws/eks-anywhere/internal/pkg/s3"
"github.com/aws/eks-anywhere/internal/pkg/ssm"
e2etests "github.com/aws/eks-anywhere/test/framework"
)
const (
openIDConfPath = "oidc/.well-known/openid-configuration"
keysPath = "oidc/keys.json"
saSignerPath = "oidc/sa-signer.key"
)
func (e *E2ESession) setupOIDC(testRegex string) error {
re := regexp.MustCompile(`^.*OIDC.*$`)
if !re.MatchString(testRegex) {
return nil
}
e.logger.V(2).Info("Creating OIDC server for the instance.")
folder := fmt.Sprintf("%s/%s", e.jobId, "generated-artifacts")
bucketUrl := s3.GetBucketPublicURL(e.session, e.storageBucket)
issuerURL := fmt.Sprintf("%s/%s/%s", bucketUrl, folder, "oidc")
e.logger.V(1).Info("OIDC test found. Checking if OIDC folder present in bucket")
oidcPresent, err := s3.ObjectPresent(e.session, filepath.Join(folder, keysPath), e.storageBucket)
if err != nil {
return fmt.Errorf("checking if oidc is present in bucket: %v", err)
}
if !oidcPresent {
e.logger.V(1).Info("OIDC not present in bucket, creating necessary files")
err = e.createOIDCFiles(issuerURL, folder)
if err != nil {
return err
}
} else {
e.logger.V(1).Info("OIDC already present in bucket, skipping setup")
}
e.logger.V(1).Info("Getting key id from s3 bucket")
keyID, err := e.getKeyID(folder)
if err != nil {
return err
}
keyPath, err := e.downloadSignerKeyInInstance(folder)
if err != nil {
return err
}
e.testEnvVars[e2etests.OIDCIssuerUrlVar] = issuerURL
e.testEnvVars[e2etests.OIDCClientIdVar] = keyID
e.testEnvVars[e2etests.OIDCKidVar] = keyID
e.testEnvVars[e2etests.OIDCKeyFileVar] = keyPath
return nil
}
func (e *E2ESession) createOIDCFiles(issuerURL, folder string) error {
provider, err := oidc.GenerateMinimalProvider(issuerURL)
if err != nil {
return fmt.Errorf("setting up generating oidc provider for s3: %v", err)
}
e.logger.V(2).Info("Uploading OIDC discovery file to S3")
discoveryKey := filepath.Join(folder, openIDConfPath)
err = s3.Upload(e.session, provider.Discovery, discoveryKey, e.storageBucket, s3.WithPublicRead())
if err != nil {
return fmt.Errorf("uploading oidc openid-configuration to s3: %v", err)
}
e.logger.V(2).Info("Uploading OIDC keys file to S3")
keysKey := filepath.Join(folder, keysPath)
err = s3.Upload(e.session, provider.Keys, keysKey, e.storageBucket, s3.WithPublicRead())
if err != nil {
return fmt.Errorf("uploading oidc keys.json to s3: %v", err)
}
e.logger.V(2).Info("Uploading OIDC signer key to S3")
saSignerKey := filepath.Join(folder, saSignerPath)
err = s3.Upload(e.session, provider.PrivateKey, saSignerKey, e.storageBucket)
if err != nil {
return fmt.Errorf("uploading oidc sa-signer.key to s3: %v", err)
}
return nil
}
func (e *E2ESession) getKeyID(folder string) (string, error) {
keysKey := filepath.Join(folder, keysPath)
e.logger.V(2).Info("Downloading keys.json file from s3")
keysBytes, err := s3.Download(e.session, keysKey, e.storageBucket)
if err != nil {
return "", fmt.Errorf("downloading keys.json to get kid: %v", err)
}
keyID, err := oidc.GetKeyID(keysBytes)
if err != nil {
return "", fmt.Errorf("getting kid from s3: %v", err)
}
return keyID, nil
}
func (e *E2ESession) downloadSignerKeyInInstance(folder string) (pathInInstance string, err error) {
saSignerKey := filepath.Join(folder, saSignerPath)
e.logger.V(1).Info("Downloading from s3 in instance", "key", saSignerKey)
command := fmt.Sprintf("aws s3 cp s3://%s/%s ./%s", e.storageBucket, saSignerKey, saSignerPath)
if err = ssm.Run(e.session, logr.Discard(), e.instanceId, command, ssmTimeout); err != nil {
return "", fmt.Errorf("downloading signer key in instance: %v", err)
}
e.logger.V(1).Info("Successfully downloaded signer key")
return saSignerPath, nil
}
| 127 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.