repo_name stringlengths 1 52 | repo_creator stringclasses 6
values | programming_language stringclasses 4
values | code stringlengths 0 9.68M | num_lines int64 1 234k |
|---|---|---|---|---|
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets details about a read set.
func (c *Client) GetReadSetMetadata(ctx context.Context, params *GetReadSetMetadataInput, optFns ...func(*Options)) (*GetReadSetMetadataOutput, error) {
if params == nil {
params = &GetReadSetMetadataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetReadSetMetadata", params, optFns, c.addOperationGetReadSetMetadataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetReadSetMetadataOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetReadSetMetadataInput struct {
// The read set's ID.
//
// This member is required.
Id *string
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
noSmithyDocumentSerde
}
type GetReadSetMetadataOutput struct {
// The read set's ARN.
//
// This member is required.
Arn *string
// When the read set was created.
//
// This member is required.
CreationTime *time.Time
// The read set's file type.
//
// This member is required.
FileType types.FileType
// The read set's ID.
//
// This member is required.
Id *string
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The read set's status.
//
// This member is required.
Status types.ReadSetStatus
// The read set's description.
Description *string
// The read set's files.
Files *types.ReadSetFiles
// The read set's name.
Name *string
// The read set's genome reference ARN.
ReferenceArn *string
// The read set's sample ID.
SampleId *string
// The read set's sequence information.
SequenceInformation *types.SequenceInformation
// The status message for a read set. It provides more detail as to why the read
// set has a status.
StatusMessage *string
// The read set's subject ID.
SubjectId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetReadSetMetadataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetReadSetMetadata{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetReadSetMetadata{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetReadSetMetadataMiddleware(stack); err != nil {
return err
}
if err = addOpGetReadSetMetadataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetReadSetMetadata(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetReadSetMetadataMiddleware struct {
}
func (*endpointPrefix_opGetReadSetMetadataMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetReadSetMetadataMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetReadSetMetadataMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetReadSetMetadataMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetReadSetMetadata(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetReadSetMetadata",
}
}
| 214 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
)
// Gets a reference file.
func (c *Client) GetReference(ctx context.Context, params *GetReferenceInput, optFns ...func(*Options)) (*GetReferenceOutput, error) {
if params == nil {
params = &GetReferenceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetReference", params, optFns, c.addOperationGetReferenceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetReferenceOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetReferenceInput struct {
// The reference's ID.
//
// This member is required.
Id *string
// The part number to retrieve.
//
// This member is required.
PartNumber *int32
// The reference's store ID.
//
// This member is required.
ReferenceStoreId *string
// The file to retrieve.
File types.ReferenceFile
// The range to retrieve.
Range *string
noSmithyDocumentSerde
}
type GetReferenceOutput struct {
// The reference file payload.
Payload io.ReadCloser
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetReferenceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetReference{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetReference{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetReferenceMiddleware(stack); err != nil {
return err
}
if err = addOpGetReferenceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetReference(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetReferenceMiddleware struct {
}
func (*endpointPrefix_opGetReferenceMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetReferenceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetReferenceMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetReferenceMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetReference(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetReference",
}
}
| 170 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Gets information about a reference import job.
func (c *Client) GetReferenceImportJob(ctx context.Context, params *GetReferenceImportJobInput, optFns ...func(*Options)) (*GetReferenceImportJobOutput, error) {
if params == nil {
params = &GetReferenceImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetReferenceImportJob", params, optFns, c.addOperationGetReferenceImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetReferenceImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetReferenceImportJobInput struct {
// The job's ID.
//
// This member is required.
Id *string
// The job's reference store ID.
//
// This member is required.
ReferenceStoreId *string
noSmithyDocumentSerde
}
type GetReferenceImportJobOutput struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's ID.
//
// This member is required.
Id *string
// The job's reference store ID.
//
// This member is required.
ReferenceStoreId *string
// The job's service role ARN.
//
// This member is required.
RoleArn *string
// The job's source files.
//
// This member is required.
Sources []types.ImportReferenceSourceItem
// The job's status.
//
// This member is required.
Status types.ReferenceImportJobStatus
// When the job completed.
CompletionTime *time.Time
// The job's status message.
StatusMessage *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetReferenceImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetReferenceImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetReferenceImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetReferenceImportJobMiddleware(stack); err != nil {
return err
}
if err = addOpGetReferenceImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetReferenceImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetReferenceImportJobMiddleware struct {
}
func (*endpointPrefix_opGetReferenceImportJobMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetReferenceImportJobMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetReferenceImportJobMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetReferenceImportJobMiddleware{}, `OperationSerializer`, middleware.After)
}
// GetReferenceImportJobAPIClient is a client that implements the
// GetReferenceImportJob operation.
type GetReferenceImportJobAPIClient interface {
GetReferenceImportJob(context.Context, *GetReferenceImportJobInput, ...func(*Options)) (*GetReferenceImportJobOutput, error)
}
var _ GetReferenceImportJobAPIClient = (*Client)(nil)
// ReferenceImportJobCompletedWaiterOptions are waiter options for
// ReferenceImportJobCompletedWaiter
type ReferenceImportJobCompletedWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// ReferenceImportJobCompletedWaiter will use default minimum delay of 30 seconds.
// Note that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, ReferenceImportJobCompletedWaiter will use default max delay of 600
// seconds. Note that MaxDelay must resolve to value greater than or equal to the
// MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetReferenceImportJobInput, *GetReferenceImportJobOutput, error) (bool, error)
}
// ReferenceImportJobCompletedWaiter defines the waiters for
// ReferenceImportJobCompleted
type ReferenceImportJobCompletedWaiter struct {
client GetReferenceImportJobAPIClient
options ReferenceImportJobCompletedWaiterOptions
}
// NewReferenceImportJobCompletedWaiter constructs a
// ReferenceImportJobCompletedWaiter.
func NewReferenceImportJobCompletedWaiter(client GetReferenceImportJobAPIClient, optFns ...func(*ReferenceImportJobCompletedWaiterOptions)) *ReferenceImportJobCompletedWaiter {
options := ReferenceImportJobCompletedWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 600 * time.Second
options.Retryable = referenceImportJobCompletedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &ReferenceImportJobCompletedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for ReferenceImportJobCompleted waiter. The
// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is
// required and must be greater than zero.
func (w *ReferenceImportJobCompletedWaiter) Wait(ctx context.Context, params *GetReferenceImportJobInput, maxWaitDur time.Duration, optFns ...func(*ReferenceImportJobCompletedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for ReferenceImportJobCompleted waiter
// and returns the output of the successful operation. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *ReferenceImportJobCompletedWaiter) WaitForOutput(ctx context.Context, params *GetReferenceImportJobInput, maxWaitDur time.Duration, optFns ...func(*ReferenceImportJobCompletedWaiterOptions)) (*GetReferenceImportJobOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 600 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetReferenceImportJob(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for ReferenceImportJobCompleted waiter")
}
func referenceImportJobCompletedStateRetryable(ctx context.Context, input *GetReferenceImportJobInput, output *GetReferenceImportJobOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "COMPLETED"
value, ok := pathValue.(types.ReferenceImportJobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ReferenceImportJobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "SUBMITTED"
value, ok := pathValue.(types.ReferenceImportJobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ReferenceImportJobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "IN_PROGRESS"
value, ok := pathValue.(types.ReferenceImportJobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ReferenceImportJobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CANCELLING"
value, ok := pathValue.(types.ReferenceImportJobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ReferenceImportJobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CANCELLED"
value, ok := pathValue.(types.ReferenceImportJobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ReferenceImportJobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "FAILED"
value, ok := pathValue.(types.ReferenceImportJobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ReferenceImportJobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "COMPLETED_WITH_FAILURES"
value, ok := pathValue.(types.ReferenceImportJobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ReferenceImportJobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetReferenceImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetReferenceImportJob",
}
}
| 472 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets information about a genome reference's metadata.
func (c *Client) GetReferenceMetadata(ctx context.Context, params *GetReferenceMetadataInput, optFns ...func(*Options)) (*GetReferenceMetadataOutput, error) {
if params == nil {
params = &GetReferenceMetadataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetReferenceMetadata", params, optFns, c.addOperationGetReferenceMetadataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetReferenceMetadataOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetReferenceMetadataInput struct {
// The reference's ID.
//
// This member is required.
Id *string
// The reference's reference store ID.
//
// This member is required.
ReferenceStoreId *string
noSmithyDocumentSerde
}
type GetReferenceMetadataOutput struct {
// The reference's ARN.
//
// This member is required.
Arn *string
// When the reference was created.
//
// This member is required.
CreationTime *time.Time
// The reference's ID.
//
// This member is required.
Id *string
// The reference's MD5 checksum.
//
// This member is required.
Md5 *string
// The reference's reference store ID.
//
// This member is required.
ReferenceStoreId *string
// When the reference was updated.
//
// This member is required.
UpdateTime *time.Time
// The reference's description.
Description *string
// The reference's files.
Files *types.ReferenceFiles
// The reference's name.
Name *string
// The reference's status.
Status types.ReferenceStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetReferenceMetadataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetReferenceMetadata{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetReferenceMetadata{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetReferenceMetadataMiddleware(stack); err != nil {
return err
}
if err = addOpGetReferenceMetadataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetReferenceMetadata(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetReferenceMetadataMiddleware struct {
}
func (*endpointPrefix_opGetReferenceMetadataMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetReferenceMetadataMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetReferenceMetadataMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetReferenceMetadataMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetReferenceMetadata(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetReferenceMetadata",
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets information about a reference store.
func (c *Client) GetReferenceStore(ctx context.Context, params *GetReferenceStoreInput, optFns ...func(*Options)) (*GetReferenceStoreOutput, error) {
if params == nil {
params = &GetReferenceStoreInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetReferenceStore", params, optFns, c.addOperationGetReferenceStoreMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetReferenceStoreOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetReferenceStoreInput struct {
// The store's ID.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetReferenceStoreOutput struct {
// The store's ARN.
//
// This member is required.
Arn *string
// When the store was created.
//
// This member is required.
CreationTime *time.Time
// The store's ID.
//
// This member is required.
Id *string
// The store's description.
Description *string
// The store's name.
Name *string
// The store's server-side encryption (SSE) settings.
SseConfig *types.SseConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetReferenceStoreMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetReferenceStore{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetReferenceStore{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetReferenceStoreMiddleware(stack); err != nil {
return err
}
if err = addOpGetReferenceStoreValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetReferenceStore(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetReferenceStoreMiddleware struct {
}
func (*endpointPrefix_opGetReferenceStoreMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetReferenceStoreMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetReferenceStoreMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetReferenceStoreMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetReferenceStore(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetReferenceStore",
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/document"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Gets information about a workflow run.
func (c *Client) GetRun(ctx context.Context, params *GetRunInput, optFns ...func(*Options)) (*GetRunOutput, error) {
if params == nil {
params = &GetRunInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetRun", params, optFns, c.addOperationGetRunMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetRunOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetRunInput struct {
// The run's ID.
//
// This member is required.
Id *string
// The run's export format.
Export []types.RunExport
noSmithyDocumentSerde
}
type GetRunOutput struct {
// The computational accelerator used to run the workflow.
Accelerators types.Accelerators
// The run's ARN.
Arn *string
// When the run was created.
CreationTime *time.Time
// The run's definition.
Definition *string
// The run's digest.
Digest *string
// The run's ID.
Id *string
// The run's log level.
LogLevel types.RunLogLevel
// The run's name.
Name *string
// The run's output URI.
OutputUri *string
// The run's parameters.
Parameters document.Interface
// The run's priority.
Priority *int32
// The run's resource digests.
ResourceDigests map[string]string
// The run's service role ARN.
RoleArn *string
// The run's group ID.
RunGroupId *string
// The run's ID.
RunId *string
// When the run started.
StartTime *time.Time
// Who started the run.
StartedBy *string
// The run's status.
Status types.RunStatus
// The run's status message.
StatusMessage *string
// The run's stop time.
StopTime *time.Time
// The run's storage capacity in gigabytes.
StorageCapacity *int32
// The run's tags.
Tags map[string]string
// The run's workflow ID.
WorkflowId *string
// The run's workflow type.
WorkflowType types.WorkflowType
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetRunMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetRun{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetRun{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetRunMiddleware(stack); err != nil {
return err
}
if err = addOpGetRunValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetRun(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetRunMiddleware struct {
}
func (*endpointPrefix_opGetRunMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetRunMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetRunMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetRunMiddleware{}, `OperationSerializer`, middleware.After)
}
// GetRunAPIClient is a client that implements the GetRun operation.
type GetRunAPIClient interface {
GetRun(context.Context, *GetRunInput, ...func(*Options)) (*GetRunOutput, error)
}
var _ GetRunAPIClient = (*Client)(nil)
// RunRunningWaiterOptions are waiter options for RunRunningWaiter
type RunRunningWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// RunRunningWaiter will use default minimum delay of 30 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, RunRunningWaiter will use default max delay of 600 seconds. Note
// that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetRunInput, *GetRunOutput, error) (bool, error)
}
// RunRunningWaiter defines the waiters for RunRunning
type RunRunningWaiter struct {
client GetRunAPIClient
options RunRunningWaiterOptions
}
// NewRunRunningWaiter constructs a RunRunningWaiter.
func NewRunRunningWaiter(client GetRunAPIClient, optFns ...func(*RunRunningWaiterOptions)) *RunRunningWaiter {
options := RunRunningWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 600 * time.Second
options.Retryable = runRunningStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &RunRunningWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for RunRunning waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *RunRunningWaiter) Wait(ctx context.Context, params *GetRunInput, maxWaitDur time.Duration, optFns ...func(*RunRunningWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for RunRunning waiter and returns the
// output of the successful operation. The maxWaitDur is the maximum wait duration
// the waiter will wait. The maxWaitDur is required and must be greater than zero.
func (w *RunRunningWaiter) WaitForOutput(ctx context.Context, params *GetRunInput, maxWaitDur time.Duration, optFns ...func(*RunRunningWaiterOptions)) (*GetRunOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 600 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetRun(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for RunRunning waiter")
}
func runRunningStateRetryable(ctx context.Context, input *GetRunInput, output *GetRunOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "RUNNING"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "PENDING"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "STARTING"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "FAILED"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CANCELLED"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
// RunCompletedWaiterOptions are waiter options for RunCompletedWaiter
type RunCompletedWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// RunCompletedWaiter will use default minimum delay of 30 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, RunCompletedWaiter will use default max delay of 600 seconds. Note
// that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetRunInput, *GetRunOutput, error) (bool, error)
}
// RunCompletedWaiter defines the waiters for RunCompleted
type RunCompletedWaiter struct {
client GetRunAPIClient
options RunCompletedWaiterOptions
}
// NewRunCompletedWaiter constructs a RunCompletedWaiter.
func NewRunCompletedWaiter(client GetRunAPIClient, optFns ...func(*RunCompletedWaiterOptions)) *RunCompletedWaiter {
options := RunCompletedWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 600 * time.Second
options.Retryable = runCompletedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &RunCompletedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for RunCompleted waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *RunCompletedWaiter) Wait(ctx context.Context, params *GetRunInput, maxWaitDur time.Duration, optFns ...func(*RunCompletedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for RunCompleted waiter and returns the
// output of the successful operation. The maxWaitDur is the maximum wait duration
// the waiter will wait. The maxWaitDur is required and must be greater than zero.
func (w *RunCompletedWaiter) WaitForOutput(ctx context.Context, params *GetRunInput, maxWaitDur time.Duration, optFns ...func(*RunCompletedWaiterOptions)) (*GetRunOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 600 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetRun(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for RunCompleted waiter")
}
func runCompletedStateRetryable(ctx context.Context, input *GetRunInput, output *GetRunOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "COMPLETED"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "PENDING"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "STARTING"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "RUNNING"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "STOPPING"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "FAILED"
value, ok := pathValue.(types.RunStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.RunStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetRun(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetRun",
}
}
| 711 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets information about a workflow run group.
func (c *Client) GetRunGroup(ctx context.Context, params *GetRunGroupInput, optFns ...func(*Options)) (*GetRunGroupOutput, error) {
if params == nil {
params = &GetRunGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetRunGroup", params, optFns, c.addOperationGetRunGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetRunGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetRunGroupInput struct {
// The group's ID.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetRunGroupOutput struct {
// The group's ARN.
Arn *string
// When the group was created.
CreationTime *time.Time
// The group's ID.
Id *string
// The group's maximum number of CPUs to use.
MaxCpus *int32
// The group's maximum run time in minutes.
MaxDuration *int32
// The maximum GPUs that can be used by a run group.
MaxGpus *int32
// The maximum number of concurrent runs for the group.
MaxRuns *int32
// The group's name.
Name *string
// The group's tags.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetRunGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetRunGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetRunGroup{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetRunGroupMiddleware(stack); err != nil {
return err
}
if err = addOpGetRunGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetRunGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetRunGroupMiddleware struct {
}
func (*endpointPrefix_opGetRunGroupMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetRunGroupMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetRunGroupMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetRunGroupMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetRunGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetRunGroup",
}
}
| 180 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Gets information about a workflow run task.
func (c *Client) GetRunTask(ctx context.Context, params *GetRunTaskInput, optFns ...func(*Options)) (*GetRunTaskOutput, error) {
if params == nil {
params = &GetRunTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetRunTask", params, optFns, c.addOperationGetRunTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetRunTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetRunTaskInput struct {
// The task's ID.
//
// This member is required.
Id *string
// The task's ID.
//
// This member is required.
TaskId *string
noSmithyDocumentSerde
}
type GetRunTaskOutput struct {
// The task's CPU usage.
Cpus *int32
// When the task was created.
CreationTime *time.Time
// The number of Graphics Processing Units (GPU) specified in the task.
Gpus *int32
// The task's log stream.
LogStream *string
// The task's memory use in gigabytes.
Memory *int32
// The task's name.
Name *string
// The task's start time.
StartTime *time.Time
// The task's status.
Status types.TaskStatus
// The task's status message.
StatusMessage *string
// The task's stop time.
StopTime *time.Time
// The task's ID.
TaskId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetRunTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetRunTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetRunTask{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetRunTaskMiddleware(stack); err != nil {
return err
}
if err = addOpGetRunTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetRunTask(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetRunTaskMiddleware struct {
}
func (*endpointPrefix_opGetRunTaskMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetRunTaskMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetRunTaskMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetRunTaskMiddleware{}, `OperationSerializer`, middleware.After)
}
// GetRunTaskAPIClient is a client that implements the GetRunTask operation.
type GetRunTaskAPIClient interface {
GetRunTask(context.Context, *GetRunTaskInput, ...func(*Options)) (*GetRunTaskOutput, error)
}
var _ GetRunTaskAPIClient = (*Client)(nil)
// TaskRunningWaiterOptions are waiter options for TaskRunningWaiter
type TaskRunningWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// TaskRunningWaiter will use default minimum delay of 30 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, TaskRunningWaiter will use default max delay of 600 seconds. Note
// that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetRunTaskInput, *GetRunTaskOutput, error) (bool, error)
}
// TaskRunningWaiter defines the waiters for TaskRunning
type TaskRunningWaiter struct {
client GetRunTaskAPIClient
options TaskRunningWaiterOptions
}
// NewTaskRunningWaiter constructs a TaskRunningWaiter.
func NewTaskRunningWaiter(client GetRunTaskAPIClient, optFns ...func(*TaskRunningWaiterOptions)) *TaskRunningWaiter {
options := TaskRunningWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 600 * time.Second
options.Retryable = taskRunningStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &TaskRunningWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for TaskRunning waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *TaskRunningWaiter) Wait(ctx context.Context, params *GetRunTaskInput, maxWaitDur time.Duration, optFns ...func(*TaskRunningWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for TaskRunning waiter and returns the
// output of the successful operation. The maxWaitDur is the maximum wait duration
// the waiter will wait. The maxWaitDur is required and must be greater than zero.
func (w *TaskRunningWaiter) WaitForOutput(ctx context.Context, params *GetRunTaskInput, maxWaitDur time.Duration, optFns ...func(*TaskRunningWaiterOptions)) (*GetRunTaskOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 600 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetRunTask(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for TaskRunning waiter")
}
func taskRunningStateRetryable(ctx context.Context, input *GetRunTaskInput, output *GetRunTaskOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "RUNNING"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "PENDING"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "STARTING"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "FAILED"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CANCELLED"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
// TaskCompletedWaiterOptions are waiter options for TaskCompletedWaiter
type TaskCompletedWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// TaskCompletedWaiter will use default minimum delay of 30 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, TaskCompletedWaiter will use default max delay of 600 seconds. Note
// that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetRunTaskInput, *GetRunTaskOutput, error) (bool, error)
}
// TaskCompletedWaiter defines the waiters for TaskCompleted
type TaskCompletedWaiter struct {
client GetRunTaskAPIClient
options TaskCompletedWaiterOptions
}
// NewTaskCompletedWaiter constructs a TaskCompletedWaiter.
func NewTaskCompletedWaiter(client GetRunTaskAPIClient, optFns ...func(*TaskCompletedWaiterOptions)) *TaskCompletedWaiter {
options := TaskCompletedWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 600 * time.Second
options.Retryable = taskCompletedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &TaskCompletedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for TaskCompleted waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *TaskCompletedWaiter) Wait(ctx context.Context, params *GetRunTaskInput, maxWaitDur time.Duration, optFns ...func(*TaskCompletedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for TaskCompleted waiter and returns
// the output of the successful operation. The maxWaitDur is the maximum wait
// duration the waiter will wait. The maxWaitDur is required and must be greater
// than zero.
func (w *TaskCompletedWaiter) WaitForOutput(ctx context.Context, params *GetRunTaskInput, maxWaitDur time.Duration, optFns ...func(*TaskCompletedWaiterOptions)) (*GetRunTaskOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 600 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetRunTask(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for TaskCompleted waiter")
}
func taskCompletedStateRetryable(ctx context.Context, input *GetRunTaskInput, output *GetRunTaskOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "COMPLETED"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "PENDING"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "STARTING"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "RUNNING"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "STOPPING"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "FAILED"
value, ok := pathValue.(types.TaskStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.TaskStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetRunTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetRunTask",
}
}
| 674 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets information about a sequence store.
func (c *Client) GetSequenceStore(ctx context.Context, params *GetSequenceStoreInput, optFns ...func(*Options)) (*GetSequenceStoreOutput, error) {
if params == nil {
params = &GetSequenceStoreInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSequenceStore", params, optFns, c.addOperationGetSequenceStoreMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSequenceStoreOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSequenceStoreInput struct {
// The store's ID.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetSequenceStoreOutput struct {
// The store's ARN.
//
// This member is required.
Arn *string
// When the store was created.
//
// This member is required.
CreationTime *time.Time
// The store's ID.
//
// This member is required.
Id *string
// The store's description.
Description *string
// An S3 location that is used to store files that have failed a direct upload.
FallbackLocation *string
// The store's name.
Name *string
// The store's server-side encryption (SSE) settings.
SseConfig *types.SseConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSequenceStoreMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetSequenceStore{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetSequenceStore{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetSequenceStoreMiddleware(stack); err != nil {
return err
}
if err = addOpGetSequenceStoreValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSequenceStore(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetSequenceStoreMiddleware struct {
}
func (*endpointPrefix_opGetSequenceStoreMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetSequenceStoreMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetSequenceStoreMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetSequenceStoreMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opGetSequenceStore(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetSequenceStore",
}
}
| 181 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Gets information about a variant import job.
func (c *Client) GetVariantImportJob(ctx context.Context, params *GetVariantImportJobInput, optFns ...func(*Options)) (*GetVariantImportJobOutput, error) {
if params == nil {
params = &GetVariantImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetVariantImportJob", params, optFns, c.addOperationGetVariantImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetVariantImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetVariantImportJobInput struct {
// The job's ID.
//
// This member is required.
JobId *string
noSmithyDocumentSerde
}
type GetVariantImportJobOutput struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's destination variant store.
//
// This member is required.
DestinationName *string
// The job's ID.
//
// This member is required.
Id *string
// The job's items.
//
// This member is required.
Items []types.VariantImportItemDetail
// The job's service role ARN.
//
// This member is required.
RoleArn *string
// The job's left normalization setting.
//
// This member is required.
RunLeftNormalization bool
// The job's status.
//
// This member is required.
Status types.JobStatus
// The job's status message.
//
// This member is required.
StatusMessage *string
// When the job was updated.
//
// This member is required.
UpdateTime *time.Time
// The annotation schema generated by the parsed annotation data.
AnnotationFields map[string]string
// When the job completed.
CompletionTime *time.Time
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetVariantImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetVariantImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetVariantImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetVariantImportJobMiddleware(stack); err != nil {
return err
}
if err = addOpGetVariantImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetVariantImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetVariantImportJobMiddleware struct {
}
func (*endpointPrefix_opGetVariantImportJobMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetVariantImportJobMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetVariantImportJobMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetVariantImportJobMiddleware{}, `OperationSerializer`, middleware.After)
}
// GetVariantImportJobAPIClient is a client that implements the
// GetVariantImportJob operation.
type GetVariantImportJobAPIClient interface {
GetVariantImportJob(context.Context, *GetVariantImportJobInput, ...func(*Options)) (*GetVariantImportJobOutput, error)
}
var _ GetVariantImportJobAPIClient = (*Client)(nil)
// VariantImportJobCreatedWaiterOptions are waiter options for
// VariantImportJobCreatedWaiter
type VariantImportJobCreatedWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// VariantImportJobCreatedWaiter will use default minimum delay of 30 seconds. Note
// that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, VariantImportJobCreatedWaiter will use default max delay of 600
// seconds. Note that MaxDelay must resolve to value greater than or equal to the
// MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetVariantImportJobInput, *GetVariantImportJobOutput, error) (bool, error)
}
// VariantImportJobCreatedWaiter defines the waiters for VariantImportJobCreated
type VariantImportJobCreatedWaiter struct {
client GetVariantImportJobAPIClient
options VariantImportJobCreatedWaiterOptions
}
// NewVariantImportJobCreatedWaiter constructs a VariantImportJobCreatedWaiter.
func NewVariantImportJobCreatedWaiter(client GetVariantImportJobAPIClient, optFns ...func(*VariantImportJobCreatedWaiterOptions)) *VariantImportJobCreatedWaiter {
options := VariantImportJobCreatedWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 600 * time.Second
options.Retryable = variantImportJobCreatedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &VariantImportJobCreatedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for VariantImportJobCreated waiter. The
// maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is
// required and must be greater than zero.
func (w *VariantImportJobCreatedWaiter) Wait(ctx context.Context, params *GetVariantImportJobInput, maxWaitDur time.Duration, optFns ...func(*VariantImportJobCreatedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for VariantImportJobCreated waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *VariantImportJobCreatedWaiter) WaitForOutput(ctx context.Context, params *GetVariantImportJobInput, maxWaitDur time.Duration, optFns ...func(*VariantImportJobCreatedWaiterOptions)) (*GetVariantImportJobOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 600 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetVariantImportJob(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for VariantImportJobCreated waiter")
}
func variantImportJobCreatedStateRetryable(ctx context.Context, input *GetVariantImportJobInput, output *GetVariantImportJobOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "SUBMITTED"
value, ok := pathValue.(types.JobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.JobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "IN_PROGRESS"
value, ok := pathValue.(types.JobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.JobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "FAILED"
value, ok := pathValue.(types.JobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.JobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CANCELLED"
value, ok := pathValue.(types.JobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.JobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "COMPLETED"
value, ok := pathValue.(types.JobStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.JobStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetVariantImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetVariantImportJob",
}
}
| 446 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"errors"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Gets information about a variant store.
func (c *Client) GetVariantStore(ctx context.Context, params *GetVariantStoreInput, optFns ...func(*Options)) (*GetVariantStoreOutput, error) {
if params == nil {
params = &GetVariantStoreInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetVariantStore", params, optFns, c.addOperationGetVariantStoreMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetVariantStoreOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetVariantStoreInput struct {
// The store's name.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
type GetVariantStoreOutput struct {
// When the store was created.
//
// This member is required.
CreationTime *time.Time
// The store's description.
//
// This member is required.
Description *string
// The store's ID.
//
// This member is required.
Id *string
// The store's name.
//
// This member is required.
Name *string
// The store's genome reference.
//
// This member is required.
Reference types.ReferenceItem
// The store's server-side encryption (SSE) settings.
//
// This member is required.
SseConfig *types.SseConfig
// The store's status.
//
// This member is required.
Status types.StoreStatus
// The store's status message.
//
// This member is required.
StatusMessage *string
// The store's ARN.
//
// This member is required.
StoreArn *string
// The store's size in bytes.
//
// This member is required.
StoreSizeBytes *int64
// The store's tags.
//
// This member is required.
Tags map[string]string
// When the store was updated.
//
// This member is required.
UpdateTime *time.Time
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetVariantStoreMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetVariantStore{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetVariantStore{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetVariantStoreMiddleware(stack); err != nil {
return err
}
if err = addOpGetVariantStoreValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetVariantStore(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetVariantStoreMiddleware struct {
}
func (*endpointPrefix_opGetVariantStoreMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetVariantStoreMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetVariantStoreMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetVariantStoreMiddleware{}, `OperationSerializer`, middleware.After)
}
// GetVariantStoreAPIClient is a client that implements the GetVariantStore
// operation.
type GetVariantStoreAPIClient interface {
GetVariantStore(context.Context, *GetVariantStoreInput, ...func(*Options)) (*GetVariantStoreOutput, error)
}
var _ GetVariantStoreAPIClient = (*Client)(nil)
// VariantStoreCreatedWaiterOptions are waiter options for
// VariantStoreCreatedWaiter
type VariantStoreCreatedWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// VariantStoreCreatedWaiter will use default minimum delay of 30 seconds. Note
// that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, VariantStoreCreatedWaiter will use default max delay of 600
// seconds. Note that MaxDelay must resolve to value greater than or equal to the
// MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetVariantStoreInput, *GetVariantStoreOutput, error) (bool, error)
}
// VariantStoreCreatedWaiter defines the waiters for VariantStoreCreated
type VariantStoreCreatedWaiter struct {
client GetVariantStoreAPIClient
options VariantStoreCreatedWaiterOptions
}
// NewVariantStoreCreatedWaiter constructs a VariantStoreCreatedWaiter.
func NewVariantStoreCreatedWaiter(client GetVariantStoreAPIClient, optFns ...func(*VariantStoreCreatedWaiterOptions)) *VariantStoreCreatedWaiter {
options := VariantStoreCreatedWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 600 * time.Second
options.Retryable = variantStoreCreatedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &VariantStoreCreatedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for VariantStoreCreated waiter. The maxWaitDur
// is the maximum wait duration the waiter will wait. The maxWaitDur is required
// and must be greater than zero.
func (w *VariantStoreCreatedWaiter) Wait(ctx context.Context, params *GetVariantStoreInput, maxWaitDur time.Duration, optFns ...func(*VariantStoreCreatedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for VariantStoreCreated waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *VariantStoreCreatedWaiter) WaitForOutput(ctx context.Context, params *GetVariantStoreInput, maxWaitDur time.Duration, optFns ...func(*VariantStoreCreatedWaiterOptions)) (*GetVariantStoreOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 600 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetVariantStore(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for VariantStoreCreated waiter")
}
func variantStoreCreatedStateRetryable(ctx context.Context, input *GetVariantStoreInput, output *GetVariantStoreOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "ACTIVE"
value, ok := pathValue.(types.StoreStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.StoreStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CREATING"
value, ok := pathValue.(types.StoreStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.StoreStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "UPDATING"
value, ok := pathValue.(types.StoreStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.StoreStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "FAILED"
value, ok := pathValue.(types.StoreStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.StoreStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
// VariantStoreDeletedWaiterOptions are waiter options for
// VariantStoreDeletedWaiter
type VariantStoreDeletedWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// VariantStoreDeletedWaiter will use default minimum delay of 30 seconds. Note
// that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, VariantStoreDeletedWaiter will use default max delay of 600
// seconds. Note that MaxDelay must resolve to value greater than or equal to the
// MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetVariantStoreInput, *GetVariantStoreOutput, error) (bool, error)
}
// VariantStoreDeletedWaiter defines the waiters for VariantStoreDeleted
type VariantStoreDeletedWaiter struct {
client GetVariantStoreAPIClient
options VariantStoreDeletedWaiterOptions
}
// NewVariantStoreDeletedWaiter constructs a VariantStoreDeletedWaiter.
func NewVariantStoreDeletedWaiter(client GetVariantStoreAPIClient, optFns ...func(*VariantStoreDeletedWaiterOptions)) *VariantStoreDeletedWaiter {
options := VariantStoreDeletedWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 600 * time.Second
options.Retryable = variantStoreDeletedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &VariantStoreDeletedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for VariantStoreDeleted waiter. The maxWaitDur
// is the maximum wait duration the waiter will wait. The maxWaitDur is required
// and must be greater than zero.
func (w *VariantStoreDeletedWaiter) Wait(ctx context.Context, params *GetVariantStoreInput, maxWaitDur time.Duration, optFns ...func(*VariantStoreDeletedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for VariantStoreDeleted waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *VariantStoreDeletedWaiter) WaitForOutput(ctx context.Context, params *GetVariantStoreInput, maxWaitDur time.Duration, optFns ...func(*VariantStoreDeletedWaiterOptions)) (*GetVariantStoreOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 600 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetVariantStore(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for VariantStoreDeleted waiter")
}
func variantStoreDeletedStateRetryable(ctx context.Context, input *GetVariantStoreInput, output *GetVariantStoreOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "DELETED"
value, ok := pathValue.(types.StoreStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.StoreStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err != nil {
var errorType *types.ResourceNotFoundException
if errors.As(err, &errorType) {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "DELETING"
value, ok := pathValue.(types.StoreStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.StoreStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetVariantStore(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetVariantStore",
}
}
| 625 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Gets information about a workflow.
func (c *Client) GetWorkflow(ctx context.Context, params *GetWorkflowInput, optFns ...func(*Options)) (*GetWorkflowOutput, error) {
if params == nil {
params = &GetWorkflowInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWorkflow", params, optFns, c.addOperationGetWorkflowMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWorkflowOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWorkflowInput struct {
// The workflow's ID.
//
// This member is required.
Id *string
// The export format for the workflow.
Export []types.WorkflowExport
// The workflow's type.
Type types.WorkflowType
noSmithyDocumentSerde
}
type GetWorkflowOutput struct {
// The computational accelerator specified to run the workflow.
Accelerators types.Accelerators
// The workflow's ARN.
Arn *string
// When the workflow was created.
CreationTime *time.Time
// The workflow's definition.
Definition *string
// The workflow's description.
Description *string
// The workflow's digest.
Digest *string
// The workflow's engine.
Engine types.WorkflowEngine
// The workflow's ID.
Id *string
// The path of the main definition file for the workflow.
Main *string
// Gets metadata for workflow.
Metadata map[string]string
// The workflow's name.
Name *string
// The workflow's parameter template.
ParameterTemplate map[string]types.WorkflowParameter
// The workflow's status.
Status types.WorkflowStatus
// The workflow's status message.
StatusMessage *string
// The workflow's storage capacity in gigabytes.
StorageCapacity *int32
// The workflow's tags.
Tags map[string]string
// The workflow's type.
Type types.WorkflowType
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWorkflowMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWorkflow{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWorkflow{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opGetWorkflowMiddleware(stack); err != nil {
return err
}
if err = addOpGetWorkflowValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWorkflow(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opGetWorkflowMiddleware struct {
}
func (*endpointPrefix_opGetWorkflowMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opGetWorkflowMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opGetWorkflowMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opGetWorkflowMiddleware{}, `OperationSerializer`, middleware.After)
}
// GetWorkflowAPIClient is a client that implements the GetWorkflow operation.
type GetWorkflowAPIClient interface {
GetWorkflow(context.Context, *GetWorkflowInput, ...func(*Options)) (*GetWorkflowOutput, error)
}
var _ GetWorkflowAPIClient = (*Client)(nil)
// WorkflowActiveWaiterOptions are waiter options for WorkflowActiveWaiter
type WorkflowActiveWaiterOptions struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// MinDelay is the minimum amount of time to delay between retries. If unset,
// WorkflowActiveWaiter will use default minimum delay of 3 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, WorkflowActiveWaiter will use default max delay of 30 seconds. Note
// that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetWorkflowInput, *GetWorkflowOutput, error) (bool, error)
}
// WorkflowActiveWaiter defines the waiters for WorkflowActive
type WorkflowActiveWaiter struct {
client GetWorkflowAPIClient
options WorkflowActiveWaiterOptions
}
// NewWorkflowActiveWaiter constructs a WorkflowActiveWaiter.
func NewWorkflowActiveWaiter(client GetWorkflowAPIClient, optFns ...func(*WorkflowActiveWaiterOptions)) *WorkflowActiveWaiter {
options := WorkflowActiveWaiterOptions{}
options.MinDelay = 3 * time.Second
options.MaxDelay = 30 * time.Second
options.Retryable = workflowActiveStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &WorkflowActiveWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for WorkflowActive waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *WorkflowActiveWaiter) Wait(ctx context.Context, params *GetWorkflowInput, maxWaitDur time.Duration, optFns ...func(*WorkflowActiveWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for WorkflowActive waiter and returns
// the output of the successful operation. The maxWaitDur is the maximum wait
// duration the waiter will wait. The maxWaitDur is required and must be greater
// than zero.
func (w *WorkflowActiveWaiter) WaitForOutput(ctx context.Context, params *GetWorkflowInput, maxWaitDur time.Duration, optFns ...func(*WorkflowActiveWaiterOptions)) (*GetWorkflowOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 30 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetWorkflow(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for WorkflowActive waiter")
}
func workflowActiveStateRetryable(ctx context.Context, input *GetWorkflowInput, output *GetWorkflowOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "ACTIVE"
value, ok := pathValue.(types.WorkflowStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.WorkflowStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CREATING"
value, ok := pathValue.(types.WorkflowStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.WorkflowStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "UPDATING"
value, ok := pathValue.(types.WorkflowStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.WorkflowStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return true, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("status", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "FAILED"
value, ok := pathValue.(types.WorkflowStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.WorkflowStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetWorkflow(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "GetWorkflow",
}
}
| 432 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of annotation import jobs.
func (c *Client) ListAnnotationImportJobs(ctx context.Context, params *ListAnnotationImportJobsInput, optFns ...func(*Options)) (*ListAnnotationImportJobsOutput, error) {
if params == nil {
params = &ListAnnotationImportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAnnotationImportJobs", params, optFns, c.addOperationListAnnotationImportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAnnotationImportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAnnotationImportJobsInput struct {
// A filter to apply to the list.
Filter *types.ListAnnotationImportJobsFilter
// IDs of annotation import jobs to retrieve.
Ids []string
// The maximum number of jobs to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListAnnotationImportJobsOutput struct {
// A list of jobs.
AnnotationImportJobs []types.AnnotationImportJobItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAnnotationImportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAnnotationImportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAnnotationImportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListAnnotationImportJobsMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAnnotationImportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListAnnotationImportJobsMiddleware struct {
}
func (*endpointPrefix_opListAnnotationImportJobsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListAnnotationImportJobsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListAnnotationImportJobsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListAnnotationImportJobsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListAnnotationImportJobsAPIClient is a client that implements the
// ListAnnotationImportJobs operation.
type ListAnnotationImportJobsAPIClient interface {
ListAnnotationImportJobs(context.Context, *ListAnnotationImportJobsInput, ...func(*Options)) (*ListAnnotationImportJobsOutput, error)
}
var _ ListAnnotationImportJobsAPIClient = (*Client)(nil)
// ListAnnotationImportJobsPaginatorOptions is the paginator options for
// ListAnnotationImportJobs
type ListAnnotationImportJobsPaginatorOptions struct {
// The maximum number of jobs to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListAnnotationImportJobsPaginator is a paginator for ListAnnotationImportJobs
type ListAnnotationImportJobsPaginator struct {
options ListAnnotationImportJobsPaginatorOptions
client ListAnnotationImportJobsAPIClient
params *ListAnnotationImportJobsInput
nextToken *string
firstPage bool
}
// NewListAnnotationImportJobsPaginator returns a new
// ListAnnotationImportJobsPaginator
func NewListAnnotationImportJobsPaginator(client ListAnnotationImportJobsAPIClient, params *ListAnnotationImportJobsInput, optFns ...func(*ListAnnotationImportJobsPaginatorOptions)) *ListAnnotationImportJobsPaginator {
if params == nil {
params = &ListAnnotationImportJobsInput{}
}
options := ListAnnotationImportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAnnotationImportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAnnotationImportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAnnotationImportJobs page.
func (p *ListAnnotationImportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAnnotationImportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListAnnotationImportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListAnnotationImportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListAnnotationImportJobs",
}
}
| 256 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of annotation stores.
func (c *Client) ListAnnotationStores(ctx context.Context, params *ListAnnotationStoresInput, optFns ...func(*Options)) (*ListAnnotationStoresOutput, error) {
if params == nil {
params = &ListAnnotationStoresInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAnnotationStores", params, optFns, c.addOperationListAnnotationStoresMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAnnotationStoresOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAnnotationStoresInput struct {
// A filter to apply to the list.
Filter *types.ListAnnotationStoresFilter
// IDs of stores to list.
Ids []string
// The maximum number of stores to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListAnnotationStoresOutput struct {
// A list of stores.
AnnotationStores []types.AnnotationStoreItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAnnotationStoresMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAnnotationStores{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAnnotationStores{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListAnnotationStoresMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAnnotationStores(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListAnnotationStoresMiddleware struct {
}
func (*endpointPrefix_opListAnnotationStoresMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListAnnotationStoresMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListAnnotationStoresMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListAnnotationStoresMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListAnnotationStoresAPIClient is a client that implements the
// ListAnnotationStores operation.
type ListAnnotationStoresAPIClient interface {
ListAnnotationStores(context.Context, *ListAnnotationStoresInput, ...func(*Options)) (*ListAnnotationStoresOutput, error)
}
var _ ListAnnotationStoresAPIClient = (*Client)(nil)
// ListAnnotationStoresPaginatorOptions is the paginator options for
// ListAnnotationStores
type ListAnnotationStoresPaginatorOptions struct {
// The maximum number of stores to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListAnnotationStoresPaginator is a paginator for ListAnnotationStores
type ListAnnotationStoresPaginator struct {
options ListAnnotationStoresPaginatorOptions
client ListAnnotationStoresAPIClient
params *ListAnnotationStoresInput
nextToken *string
firstPage bool
}
// NewListAnnotationStoresPaginator returns a new ListAnnotationStoresPaginator
func NewListAnnotationStoresPaginator(client ListAnnotationStoresAPIClient, params *ListAnnotationStoresInput, optFns ...func(*ListAnnotationStoresPaginatorOptions)) *ListAnnotationStoresPaginator {
if params == nil {
params = &ListAnnotationStoresInput{}
}
options := ListAnnotationStoresPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAnnotationStoresPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAnnotationStoresPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAnnotationStores page.
func (p *ListAnnotationStoresPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAnnotationStoresOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListAnnotationStores(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListAnnotationStores(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListAnnotationStores",
}
}
| 255 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all multipart read set uploads and their statuses.
func (c *Client) ListMultipartReadSetUploads(ctx context.Context, params *ListMultipartReadSetUploadsInput, optFns ...func(*Options)) (*ListMultipartReadSetUploadsOutput, error) {
if params == nil {
params = &ListMultipartReadSetUploadsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMultipartReadSetUploads", params, optFns, c.addOperationListMultipartReadSetUploadsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMultipartReadSetUploadsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMultipartReadSetUploadsInput struct {
// The Sequence Store ID used for the multipart uploads.
//
// This member is required.
SequenceStoreId *string
// The maximum number of multipart uploads returned in a page.
MaxResults *int32
// Next token returned in the response of a previous ListMultipartReadSetUploads
// call. Used to get the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type ListMultipartReadSetUploadsOutput struct {
// Next token returned in the response of a previous ListMultipartReadSetUploads
// call. Used to get the next page of results.
NextToken *string
// An array of multipart uploads.
Uploads []types.MultipartReadSetUploadListItem
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMultipartReadSetUploadsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListMultipartReadSetUploads{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListMultipartReadSetUploads{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListMultipartReadSetUploadsMiddleware(stack); err != nil {
return err
}
if err = addOpListMultipartReadSetUploadsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListMultipartReadSetUploads(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListMultipartReadSetUploadsMiddleware struct {
}
func (*endpointPrefix_opListMultipartReadSetUploadsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListMultipartReadSetUploadsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListMultipartReadSetUploadsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListMultipartReadSetUploadsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListMultipartReadSetUploadsAPIClient is a client that implements the
// ListMultipartReadSetUploads operation.
type ListMultipartReadSetUploadsAPIClient interface {
ListMultipartReadSetUploads(context.Context, *ListMultipartReadSetUploadsInput, ...func(*Options)) (*ListMultipartReadSetUploadsOutput, error)
}
var _ ListMultipartReadSetUploadsAPIClient = (*Client)(nil)
// ListMultipartReadSetUploadsPaginatorOptions is the paginator options for
// ListMultipartReadSetUploads
type ListMultipartReadSetUploadsPaginatorOptions struct {
// The maximum number of multipart uploads returned in a page.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListMultipartReadSetUploadsPaginator is a paginator for
// ListMultipartReadSetUploads
type ListMultipartReadSetUploadsPaginator struct {
options ListMultipartReadSetUploadsPaginatorOptions
client ListMultipartReadSetUploadsAPIClient
params *ListMultipartReadSetUploadsInput
nextToken *string
firstPage bool
}
// NewListMultipartReadSetUploadsPaginator returns a new
// ListMultipartReadSetUploadsPaginator
func NewListMultipartReadSetUploadsPaginator(client ListMultipartReadSetUploadsAPIClient, params *ListMultipartReadSetUploadsInput, optFns ...func(*ListMultipartReadSetUploadsPaginatorOptions)) *ListMultipartReadSetUploadsPaginator {
if params == nil {
params = &ListMultipartReadSetUploadsInput{}
}
options := ListMultipartReadSetUploadsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMultipartReadSetUploadsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMultipartReadSetUploadsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMultipartReadSetUploads page.
func (p *ListMultipartReadSetUploadsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMultipartReadSetUploadsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListMultipartReadSetUploads(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListMultipartReadSetUploads(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListMultipartReadSetUploads",
}
}
| 260 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of read set activation jobs.
func (c *Client) ListReadSetActivationJobs(ctx context.Context, params *ListReadSetActivationJobsInput, optFns ...func(*Options)) (*ListReadSetActivationJobsOutput, error) {
if params == nil {
params = &ListReadSetActivationJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListReadSetActivationJobs", params, optFns, c.addOperationListReadSetActivationJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListReadSetActivationJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListReadSetActivationJobsInput struct {
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// A filter to apply to the list.
Filter *types.ActivateReadSetFilter
// The maximum number of read set activation jobs to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListReadSetActivationJobsOutput struct {
// A list of jobs.
ActivationJobs []types.ActivateReadSetJobItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListReadSetActivationJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListReadSetActivationJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListReadSetActivationJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListReadSetActivationJobsMiddleware(stack); err != nil {
return err
}
if err = addOpListReadSetActivationJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListReadSetActivationJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListReadSetActivationJobsMiddleware struct {
}
func (*endpointPrefix_opListReadSetActivationJobsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListReadSetActivationJobsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListReadSetActivationJobsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListReadSetActivationJobsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListReadSetActivationJobsAPIClient is a client that implements the
// ListReadSetActivationJobs operation.
type ListReadSetActivationJobsAPIClient interface {
ListReadSetActivationJobs(context.Context, *ListReadSetActivationJobsInput, ...func(*Options)) (*ListReadSetActivationJobsOutput, error)
}
var _ ListReadSetActivationJobsAPIClient = (*Client)(nil)
// ListReadSetActivationJobsPaginatorOptions is the paginator options for
// ListReadSetActivationJobs
type ListReadSetActivationJobsPaginatorOptions struct {
// The maximum number of read set activation jobs to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListReadSetActivationJobsPaginator is a paginator for ListReadSetActivationJobs
type ListReadSetActivationJobsPaginator struct {
options ListReadSetActivationJobsPaginatorOptions
client ListReadSetActivationJobsAPIClient
params *ListReadSetActivationJobsInput
nextToken *string
firstPage bool
}
// NewListReadSetActivationJobsPaginator returns a new
// ListReadSetActivationJobsPaginator
func NewListReadSetActivationJobsPaginator(client ListReadSetActivationJobsAPIClient, params *ListReadSetActivationJobsInput, optFns ...func(*ListReadSetActivationJobsPaginatorOptions)) *ListReadSetActivationJobsPaginator {
if params == nil {
params = &ListReadSetActivationJobsInput{}
}
options := ListReadSetActivationJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListReadSetActivationJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListReadSetActivationJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListReadSetActivationJobs page.
func (p *ListReadSetActivationJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReadSetActivationJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListReadSetActivationJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListReadSetActivationJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListReadSetActivationJobs",
}
}
| 261 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of read set export jobs.
func (c *Client) ListReadSetExportJobs(ctx context.Context, params *ListReadSetExportJobsInput, optFns ...func(*Options)) (*ListReadSetExportJobsOutput, error) {
if params == nil {
params = &ListReadSetExportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListReadSetExportJobs", params, optFns, c.addOperationListReadSetExportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListReadSetExportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListReadSetExportJobsInput struct {
// The jobs' sequence store ID.
//
// This member is required.
SequenceStoreId *string
// A filter to apply to the list.
Filter *types.ExportReadSetFilter
// The maximum number of jobs to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListReadSetExportJobsOutput struct {
// A list of jobs.
ExportJobs []types.ExportReadSetJobDetail
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListReadSetExportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListReadSetExportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListReadSetExportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListReadSetExportJobsMiddleware(stack); err != nil {
return err
}
if err = addOpListReadSetExportJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListReadSetExportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListReadSetExportJobsMiddleware struct {
}
func (*endpointPrefix_opListReadSetExportJobsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListReadSetExportJobsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListReadSetExportJobsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListReadSetExportJobsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListReadSetExportJobsAPIClient is a client that implements the
// ListReadSetExportJobs operation.
type ListReadSetExportJobsAPIClient interface {
ListReadSetExportJobs(context.Context, *ListReadSetExportJobsInput, ...func(*Options)) (*ListReadSetExportJobsOutput, error)
}
var _ ListReadSetExportJobsAPIClient = (*Client)(nil)
// ListReadSetExportJobsPaginatorOptions is the paginator options for
// ListReadSetExportJobs
type ListReadSetExportJobsPaginatorOptions struct {
// The maximum number of jobs to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListReadSetExportJobsPaginator is a paginator for ListReadSetExportJobs
type ListReadSetExportJobsPaginator struct {
options ListReadSetExportJobsPaginatorOptions
client ListReadSetExportJobsAPIClient
params *ListReadSetExportJobsInput
nextToken *string
firstPage bool
}
// NewListReadSetExportJobsPaginator returns a new ListReadSetExportJobsPaginator
func NewListReadSetExportJobsPaginator(client ListReadSetExportJobsAPIClient, params *ListReadSetExportJobsInput, optFns ...func(*ListReadSetExportJobsPaginatorOptions)) *ListReadSetExportJobsPaginator {
if params == nil {
params = &ListReadSetExportJobsInput{}
}
options := ListReadSetExportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListReadSetExportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListReadSetExportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListReadSetExportJobs page.
func (p *ListReadSetExportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReadSetExportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListReadSetExportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListReadSetExportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListReadSetExportJobs",
}
}
| 260 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of read set import jobs.
func (c *Client) ListReadSetImportJobs(ctx context.Context, params *ListReadSetImportJobsInput, optFns ...func(*Options)) (*ListReadSetImportJobsOutput, error) {
if params == nil {
params = &ListReadSetImportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListReadSetImportJobs", params, optFns, c.addOperationListReadSetImportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListReadSetImportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListReadSetImportJobsInput struct {
// The jobs' sequence store ID.
//
// This member is required.
SequenceStoreId *string
// A filter to apply to the list.
Filter *types.ImportReadSetFilter
// The maximum number of jobs to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListReadSetImportJobsOutput struct {
// A list of jobs.
ImportJobs []types.ImportReadSetJobItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListReadSetImportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListReadSetImportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListReadSetImportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListReadSetImportJobsMiddleware(stack); err != nil {
return err
}
if err = addOpListReadSetImportJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListReadSetImportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListReadSetImportJobsMiddleware struct {
}
func (*endpointPrefix_opListReadSetImportJobsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListReadSetImportJobsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListReadSetImportJobsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListReadSetImportJobsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListReadSetImportJobsAPIClient is a client that implements the
// ListReadSetImportJobs operation.
type ListReadSetImportJobsAPIClient interface {
ListReadSetImportJobs(context.Context, *ListReadSetImportJobsInput, ...func(*Options)) (*ListReadSetImportJobsOutput, error)
}
var _ ListReadSetImportJobsAPIClient = (*Client)(nil)
// ListReadSetImportJobsPaginatorOptions is the paginator options for
// ListReadSetImportJobs
type ListReadSetImportJobsPaginatorOptions struct {
// The maximum number of jobs to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListReadSetImportJobsPaginator is a paginator for ListReadSetImportJobs
type ListReadSetImportJobsPaginator struct {
options ListReadSetImportJobsPaginatorOptions
client ListReadSetImportJobsAPIClient
params *ListReadSetImportJobsInput
nextToken *string
firstPage bool
}
// NewListReadSetImportJobsPaginator returns a new ListReadSetImportJobsPaginator
func NewListReadSetImportJobsPaginator(client ListReadSetImportJobsAPIClient, params *ListReadSetImportJobsInput, optFns ...func(*ListReadSetImportJobsPaginatorOptions)) *ListReadSetImportJobsPaginator {
if params == nil {
params = &ListReadSetImportJobsInput{}
}
options := ListReadSetImportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListReadSetImportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListReadSetImportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListReadSetImportJobs page.
func (p *ListReadSetImportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReadSetImportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListReadSetImportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListReadSetImportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListReadSetImportJobs",
}
}
| 260 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of read sets.
func (c *Client) ListReadSets(ctx context.Context, params *ListReadSetsInput, optFns ...func(*Options)) (*ListReadSetsOutput, error) {
if params == nil {
params = &ListReadSetsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListReadSets", params, optFns, c.addOperationListReadSetsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListReadSetsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListReadSetsInput struct {
// The jobs' sequence store ID.
//
// This member is required.
SequenceStoreId *string
// A filter to apply to the list.
Filter *types.ReadSetFilter
// The maximum number of read sets to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListReadSetsOutput struct {
// A list of read sets.
//
// This member is required.
ReadSets []types.ReadSetListItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListReadSetsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListReadSets{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListReadSets{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListReadSetsMiddleware(stack); err != nil {
return err
}
if err = addOpListReadSetsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListReadSets(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListReadSetsMiddleware struct {
}
func (*endpointPrefix_opListReadSetsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListReadSetsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListReadSetsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListReadSetsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListReadSetsAPIClient is a client that implements the ListReadSets operation.
type ListReadSetsAPIClient interface {
ListReadSets(context.Context, *ListReadSetsInput, ...func(*Options)) (*ListReadSetsOutput, error)
}
var _ ListReadSetsAPIClient = (*Client)(nil)
// ListReadSetsPaginatorOptions is the paginator options for ListReadSets
type ListReadSetsPaginatorOptions struct {
// The maximum number of read sets to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListReadSetsPaginator is a paginator for ListReadSets
type ListReadSetsPaginator struct {
options ListReadSetsPaginatorOptions
client ListReadSetsAPIClient
params *ListReadSetsInput
nextToken *string
firstPage bool
}
// NewListReadSetsPaginator returns a new ListReadSetsPaginator
func NewListReadSetsPaginator(client ListReadSetsAPIClient, params *ListReadSetsInput, optFns ...func(*ListReadSetsPaginatorOptions)) *ListReadSetsPaginator {
if params == nil {
params = &ListReadSetsInput{}
}
options := ListReadSetsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListReadSetsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListReadSetsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListReadSets page.
func (p *ListReadSetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReadSetsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListReadSets(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListReadSets(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListReadSets",
}
}
| 260 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation will list all parts in a requested multipart upload for a
// sequence store.
func (c *Client) ListReadSetUploadParts(ctx context.Context, params *ListReadSetUploadPartsInput, optFns ...func(*Options)) (*ListReadSetUploadPartsOutput, error) {
if params == nil {
params = &ListReadSetUploadPartsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListReadSetUploadParts", params, optFns, c.addOperationListReadSetUploadPartsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListReadSetUploadPartsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListReadSetUploadPartsInput struct {
// The source file for the upload part.
//
// This member is required.
PartSource types.ReadSetPartSource
// The Sequence Store ID used for the multipart uploads.
//
// This member is required.
SequenceStoreId *string
// The ID for the initiated multipart upload.
//
// This member is required.
UploadId *string
// Attributes used to filter for a specific subset of read set part uploads.
Filter *types.ReadSetUploadPartListFilter
// The maximum number of read set upload parts returned in a page.
MaxResults *int32
// Next token returned in the response of a previous ListReadSetUploadPartsRequest
// call. Used to get the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type ListReadSetUploadPartsOutput struct {
// Next token returned in the response of a previous ListReadSetUploadParts call.
// Used to get the next page of results.
NextToken *string
// An array of upload parts.
Parts []types.ReadSetUploadPartListItem
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListReadSetUploadPartsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListReadSetUploadParts{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListReadSetUploadParts{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListReadSetUploadPartsMiddleware(stack); err != nil {
return err
}
if err = addOpListReadSetUploadPartsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListReadSetUploadParts(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListReadSetUploadPartsMiddleware struct {
}
func (*endpointPrefix_opListReadSetUploadPartsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListReadSetUploadPartsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListReadSetUploadPartsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListReadSetUploadPartsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListReadSetUploadPartsAPIClient is a client that implements the
// ListReadSetUploadParts operation.
type ListReadSetUploadPartsAPIClient interface {
ListReadSetUploadParts(context.Context, *ListReadSetUploadPartsInput, ...func(*Options)) (*ListReadSetUploadPartsOutput, error)
}
var _ ListReadSetUploadPartsAPIClient = (*Client)(nil)
// ListReadSetUploadPartsPaginatorOptions is the paginator options for
// ListReadSetUploadParts
type ListReadSetUploadPartsPaginatorOptions struct {
// The maximum number of read set upload parts returned in a page.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListReadSetUploadPartsPaginator is a paginator for ListReadSetUploadParts
type ListReadSetUploadPartsPaginator struct {
options ListReadSetUploadPartsPaginatorOptions
client ListReadSetUploadPartsAPIClient
params *ListReadSetUploadPartsInput
nextToken *string
firstPage bool
}
// NewListReadSetUploadPartsPaginator returns a new ListReadSetUploadPartsPaginator
func NewListReadSetUploadPartsPaginator(client ListReadSetUploadPartsAPIClient, params *ListReadSetUploadPartsInput, optFns ...func(*ListReadSetUploadPartsPaginatorOptions)) *ListReadSetUploadPartsPaginator {
if params == nil {
params = &ListReadSetUploadPartsInput{}
}
options := ListReadSetUploadPartsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListReadSetUploadPartsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListReadSetUploadPartsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListReadSetUploadParts page.
func (p *ListReadSetUploadPartsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReadSetUploadPartsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListReadSetUploadParts(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListReadSetUploadParts(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListReadSetUploadParts",
}
}
| 272 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of reference import jobs.
func (c *Client) ListReferenceImportJobs(ctx context.Context, params *ListReferenceImportJobsInput, optFns ...func(*Options)) (*ListReferenceImportJobsOutput, error) {
if params == nil {
params = &ListReferenceImportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListReferenceImportJobs", params, optFns, c.addOperationListReferenceImportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListReferenceImportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListReferenceImportJobsInput struct {
// The job's reference store ID.
//
// This member is required.
ReferenceStoreId *string
// A filter to apply to the list.
Filter *types.ImportReferenceFilter
// The maximum number of jobs to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListReferenceImportJobsOutput struct {
// A lis of jobs.
ImportJobs []types.ImportReferenceJobItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListReferenceImportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListReferenceImportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListReferenceImportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListReferenceImportJobsMiddleware(stack); err != nil {
return err
}
if err = addOpListReferenceImportJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListReferenceImportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListReferenceImportJobsMiddleware struct {
}
func (*endpointPrefix_opListReferenceImportJobsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListReferenceImportJobsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListReferenceImportJobsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListReferenceImportJobsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListReferenceImportJobsAPIClient is a client that implements the
// ListReferenceImportJobs operation.
type ListReferenceImportJobsAPIClient interface {
ListReferenceImportJobs(context.Context, *ListReferenceImportJobsInput, ...func(*Options)) (*ListReferenceImportJobsOutput, error)
}
var _ ListReferenceImportJobsAPIClient = (*Client)(nil)
// ListReferenceImportJobsPaginatorOptions is the paginator options for
// ListReferenceImportJobs
type ListReferenceImportJobsPaginatorOptions struct {
// The maximum number of jobs to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListReferenceImportJobsPaginator is a paginator for ListReferenceImportJobs
type ListReferenceImportJobsPaginator struct {
options ListReferenceImportJobsPaginatorOptions
client ListReferenceImportJobsAPIClient
params *ListReferenceImportJobsInput
nextToken *string
firstPage bool
}
// NewListReferenceImportJobsPaginator returns a new
// ListReferenceImportJobsPaginator
func NewListReferenceImportJobsPaginator(client ListReferenceImportJobsAPIClient, params *ListReferenceImportJobsInput, optFns ...func(*ListReferenceImportJobsPaginatorOptions)) *ListReferenceImportJobsPaginator {
if params == nil {
params = &ListReferenceImportJobsInput{}
}
options := ListReferenceImportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListReferenceImportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListReferenceImportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListReferenceImportJobs page.
func (p *ListReferenceImportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReferenceImportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListReferenceImportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListReferenceImportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListReferenceImportJobs",
}
}
| 261 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of references.
func (c *Client) ListReferences(ctx context.Context, params *ListReferencesInput, optFns ...func(*Options)) (*ListReferencesOutput, error) {
if params == nil {
params = &ListReferencesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListReferences", params, optFns, c.addOperationListReferencesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListReferencesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListReferencesInput struct {
// The references' reference store ID.
//
// This member is required.
ReferenceStoreId *string
// A filter to apply to the list.
Filter *types.ReferenceFilter
// The maximum number of references to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListReferencesOutput struct {
// A list of references.
//
// This member is required.
References []types.ReferenceListItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListReferencesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListReferences{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListReferences{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListReferencesMiddleware(stack); err != nil {
return err
}
if err = addOpListReferencesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListReferences(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListReferencesMiddleware struct {
}
func (*endpointPrefix_opListReferencesMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListReferencesMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListReferencesMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListReferencesMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListReferencesAPIClient is a client that implements the ListReferences
// operation.
type ListReferencesAPIClient interface {
ListReferences(context.Context, *ListReferencesInput, ...func(*Options)) (*ListReferencesOutput, error)
}
var _ ListReferencesAPIClient = (*Client)(nil)
// ListReferencesPaginatorOptions is the paginator options for ListReferences
type ListReferencesPaginatorOptions struct {
// The maximum number of references to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListReferencesPaginator is a paginator for ListReferences
type ListReferencesPaginator struct {
options ListReferencesPaginatorOptions
client ListReferencesAPIClient
params *ListReferencesInput
nextToken *string
firstPage bool
}
// NewListReferencesPaginator returns a new ListReferencesPaginator
func NewListReferencesPaginator(client ListReferencesAPIClient, params *ListReferencesInput, optFns ...func(*ListReferencesPaginatorOptions)) *ListReferencesPaginator {
if params == nil {
params = &ListReferencesInput{}
}
options := ListReferencesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListReferencesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListReferencesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListReferences page.
func (p *ListReferencesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReferencesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListReferences(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListReferences(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListReferences",
}
}
| 261 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of reference stores.
func (c *Client) ListReferenceStores(ctx context.Context, params *ListReferenceStoresInput, optFns ...func(*Options)) (*ListReferenceStoresOutput, error) {
if params == nil {
params = &ListReferenceStoresInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListReferenceStores", params, optFns, c.addOperationListReferenceStoresMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListReferenceStoresOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListReferenceStoresInput struct {
// A filter to apply to the list.
Filter *types.ReferenceStoreFilter
// The maximum number of stores to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListReferenceStoresOutput struct {
// A list of reference stores.
//
// This member is required.
ReferenceStores []types.ReferenceStoreDetail
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListReferenceStoresMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListReferenceStores{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListReferenceStores{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListReferenceStoresMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListReferenceStores(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListReferenceStoresMiddleware struct {
}
func (*endpointPrefix_opListReferenceStoresMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListReferenceStoresMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListReferenceStoresMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListReferenceStoresMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListReferenceStoresAPIClient is a client that implements the
// ListReferenceStores operation.
type ListReferenceStoresAPIClient interface {
ListReferenceStores(context.Context, *ListReferenceStoresInput, ...func(*Options)) (*ListReferenceStoresOutput, error)
}
var _ ListReferenceStoresAPIClient = (*Client)(nil)
// ListReferenceStoresPaginatorOptions is the paginator options for
// ListReferenceStores
type ListReferenceStoresPaginatorOptions struct {
// The maximum number of stores to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListReferenceStoresPaginator is a paginator for ListReferenceStores
type ListReferenceStoresPaginator struct {
options ListReferenceStoresPaginatorOptions
client ListReferenceStoresAPIClient
params *ListReferenceStoresInput
nextToken *string
firstPage bool
}
// NewListReferenceStoresPaginator returns a new ListReferenceStoresPaginator
func NewListReferenceStoresPaginator(client ListReferenceStoresAPIClient, params *ListReferenceStoresInput, optFns ...func(*ListReferenceStoresPaginatorOptions)) *ListReferenceStoresPaginator {
if params == nil {
params = &ListReferenceStoresInput{}
}
options := ListReferenceStoresPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListReferenceStoresPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListReferenceStoresPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListReferenceStores page.
func (p *ListReferenceStoresPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReferenceStoresOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListReferenceStores(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListReferenceStores(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListReferenceStores",
}
}
| 254 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of run groups.
func (c *Client) ListRunGroups(ctx context.Context, params *ListRunGroupsInput, optFns ...func(*Options)) (*ListRunGroupsOutput, error) {
if params == nil {
params = &ListRunGroupsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListRunGroups", params, optFns, c.addOperationListRunGroupsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListRunGroupsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListRunGroupsInput struct {
// The maximum number of run groups to return in one page of results.
MaxResults *int32
// The run groups' name.
Name *string
// Specify the pagination token from a previous request to retrieve the next page
// of results.
StartingToken *string
noSmithyDocumentSerde
}
type ListRunGroupsOutput struct {
// A list of groups.
Items []types.RunGroupListItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListRunGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListRunGroups{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListRunGroups{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListRunGroupsMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListRunGroups(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListRunGroupsMiddleware struct {
}
func (*endpointPrefix_opListRunGroupsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListRunGroupsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListRunGroupsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListRunGroupsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListRunGroupsAPIClient is a client that implements the ListRunGroups operation.
type ListRunGroupsAPIClient interface {
ListRunGroups(context.Context, *ListRunGroupsInput, ...func(*Options)) (*ListRunGroupsOutput, error)
}
var _ ListRunGroupsAPIClient = (*Client)(nil)
// ListRunGroupsPaginatorOptions is the paginator options for ListRunGroups
type ListRunGroupsPaginatorOptions struct {
// The maximum number of run groups to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListRunGroupsPaginator is a paginator for ListRunGroups
type ListRunGroupsPaginator struct {
options ListRunGroupsPaginatorOptions
client ListRunGroupsAPIClient
params *ListRunGroupsInput
nextToken *string
firstPage bool
}
// NewListRunGroupsPaginator returns a new ListRunGroupsPaginator
func NewListRunGroupsPaginator(client ListRunGroupsAPIClient, params *ListRunGroupsInput, optFns ...func(*ListRunGroupsPaginatorOptions)) *ListRunGroupsPaginator {
if params == nil {
params = &ListRunGroupsInput{}
}
options := ListRunGroupsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListRunGroupsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.StartingToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListRunGroupsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListRunGroups page.
func (p *ListRunGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRunGroupsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.StartingToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListRunGroups(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListRunGroups(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListRunGroups",
}
}
| 250 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of runs.
func (c *Client) ListRuns(ctx context.Context, params *ListRunsInput, optFns ...func(*Options)) (*ListRunsOutput, error) {
if params == nil {
params = &ListRunsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListRuns", params, optFns, c.addOperationListRunsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListRunsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListRunsInput struct {
// The maximum number of runs to return in one page of results.
MaxResults *int32
// Filter the list by run name.
Name *string
// Filter the list by run group ID.
RunGroupId *string
// Specify the pagination token from a previous request to retrieve the next page
// of results.
StartingToken *string
// The status of a run.
Status types.RunStatus
noSmithyDocumentSerde
}
type ListRunsOutput struct {
// A list of runs.
Items []types.RunListItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListRunsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListRuns{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListRuns{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListRunsMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListRuns(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListRunsMiddleware struct {
}
func (*endpointPrefix_opListRunsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListRunsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListRunsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListRunsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListRunsAPIClient is a client that implements the ListRuns operation.
type ListRunsAPIClient interface {
ListRuns(context.Context, *ListRunsInput, ...func(*Options)) (*ListRunsOutput, error)
}
var _ ListRunsAPIClient = (*Client)(nil)
// ListRunsPaginatorOptions is the paginator options for ListRuns
type ListRunsPaginatorOptions struct {
// The maximum number of runs to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListRunsPaginator is a paginator for ListRuns
type ListRunsPaginator struct {
options ListRunsPaginatorOptions
client ListRunsAPIClient
params *ListRunsInput
nextToken *string
firstPage bool
}
// NewListRunsPaginator returns a new ListRunsPaginator
func NewListRunsPaginator(client ListRunsAPIClient, params *ListRunsInput, optFns ...func(*ListRunsPaginatorOptions)) *ListRunsPaginator {
if params == nil {
params = &ListRunsInput{}
}
options := ListRunsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListRunsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.StartingToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListRunsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListRuns page.
func (p *ListRunsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRunsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.StartingToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListRuns(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListRuns(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListRuns",
}
}
| 256 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of tasks for a run.
func (c *Client) ListRunTasks(ctx context.Context, params *ListRunTasksInput, optFns ...func(*Options)) (*ListRunTasksOutput, error) {
if params == nil {
params = &ListRunTasksInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListRunTasks", params, optFns, c.addOperationListRunTasksMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListRunTasksOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListRunTasksInput struct {
// The run's ID.
//
// This member is required.
Id *string
// The maximum number of run tasks to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
StartingToken *string
// Filter the list by status.
Status types.TaskStatus
noSmithyDocumentSerde
}
type ListRunTasksOutput struct {
// A list of tasks.
Items []types.TaskListItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListRunTasksMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListRunTasks{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListRunTasks{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListRunTasksMiddleware(stack); err != nil {
return err
}
if err = addOpListRunTasksValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListRunTasks(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListRunTasksMiddleware struct {
}
func (*endpointPrefix_opListRunTasksMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListRunTasksMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListRunTasksMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListRunTasksMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListRunTasksAPIClient is a client that implements the ListRunTasks operation.
type ListRunTasksAPIClient interface {
ListRunTasks(context.Context, *ListRunTasksInput, ...func(*Options)) (*ListRunTasksOutput, error)
}
var _ ListRunTasksAPIClient = (*Client)(nil)
// ListRunTasksPaginatorOptions is the paginator options for ListRunTasks
type ListRunTasksPaginatorOptions struct {
// The maximum number of run tasks to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListRunTasksPaginator is a paginator for ListRunTasks
type ListRunTasksPaginator struct {
options ListRunTasksPaginatorOptions
client ListRunTasksAPIClient
params *ListRunTasksInput
nextToken *string
firstPage bool
}
// NewListRunTasksPaginator returns a new ListRunTasksPaginator
func NewListRunTasksPaginator(client ListRunTasksAPIClient, params *ListRunTasksInput, optFns ...func(*ListRunTasksPaginatorOptions)) *ListRunTasksPaginator {
if params == nil {
params = &ListRunTasksInput{}
}
options := ListRunTasksPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListRunTasksPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.StartingToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListRunTasksPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListRunTasks page.
func (p *ListRunTasksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRunTasksOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.StartingToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListRunTasks(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListRunTasks(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListRunTasks",
}
}
| 258 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of sequence stores.
func (c *Client) ListSequenceStores(ctx context.Context, params *ListSequenceStoresInput, optFns ...func(*Options)) (*ListSequenceStoresOutput, error) {
if params == nil {
params = &ListSequenceStoresInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListSequenceStores", params, optFns, c.addOperationListSequenceStoresMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListSequenceStoresOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListSequenceStoresInput struct {
// A filter to apply to the list.
Filter *types.SequenceStoreFilter
// The maximum number of stores to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListSequenceStoresOutput struct {
// A list of sequence stores.
//
// This member is required.
SequenceStores []types.SequenceStoreDetail
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListSequenceStoresMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListSequenceStores{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListSequenceStores{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListSequenceStoresMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListSequenceStores(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListSequenceStoresMiddleware struct {
}
func (*endpointPrefix_opListSequenceStoresMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListSequenceStoresMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListSequenceStoresMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListSequenceStoresMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListSequenceStoresAPIClient is a client that implements the ListSequenceStores
// operation.
type ListSequenceStoresAPIClient interface {
ListSequenceStores(context.Context, *ListSequenceStoresInput, ...func(*Options)) (*ListSequenceStoresOutput, error)
}
var _ ListSequenceStoresAPIClient = (*Client)(nil)
// ListSequenceStoresPaginatorOptions is the paginator options for
// ListSequenceStores
type ListSequenceStoresPaginatorOptions struct {
// The maximum number of stores to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListSequenceStoresPaginator is a paginator for ListSequenceStores
type ListSequenceStoresPaginator struct {
options ListSequenceStoresPaginatorOptions
client ListSequenceStoresAPIClient
params *ListSequenceStoresInput
nextToken *string
firstPage bool
}
// NewListSequenceStoresPaginator returns a new ListSequenceStoresPaginator
func NewListSequenceStoresPaginator(client ListSequenceStoresAPIClient, params *ListSequenceStoresInput, optFns ...func(*ListSequenceStoresPaginatorOptions)) *ListSequenceStoresPaginator {
if params == nil {
params = &ListSequenceStoresInput{}
}
options := ListSequenceStoresPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListSequenceStoresPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListSequenceStoresPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListSequenceStores page.
func (p *ListSequenceStoresPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSequenceStoresOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListSequenceStores(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListSequenceStores(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListSequenceStores",
}
}
| 254 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of tags for a resource.
func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) {
if params == nil {
params = &ListTagsForResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTagsForResource", params, optFns, c.addOperationListTagsForResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTagsForResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTagsForResourceInput struct {
// The resource's ARN.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// A list of tags.
//
// This member is required.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListTagsForResourceMiddleware(stack); err != nil {
return err
}
if err = addOpListTagsForResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTagsForResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListTagsForResourceMiddleware struct {
}
func (*endpointPrefix_opListTagsForResourceMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListTagsForResourceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "tags-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListTagsForResourceMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListTagsForResourceMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opListTagsForResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListTagsForResource",
}
}
| 157 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of variant import jobs.
func (c *Client) ListVariantImportJobs(ctx context.Context, params *ListVariantImportJobsInput, optFns ...func(*Options)) (*ListVariantImportJobsOutput, error) {
if params == nil {
params = &ListVariantImportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListVariantImportJobs", params, optFns, c.addOperationListVariantImportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListVariantImportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListVariantImportJobsInput struct {
// A filter to apply to the list.
Filter *types.ListVariantImportJobsFilter
// A list of job IDs.
Ids []string
// The maximum number of import jobs to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListVariantImportJobsOutput struct {
// A pagination token that's included if more results are available.
NextToken *string
// A list of jobs.
VariantImportJobs []types.VariantImportJobItem
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListVariantImportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListVariantImportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListVariantImportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListVariantImportJobsMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListVariantImportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListVariantImportJobsMiddleware struct {
}
func (*endpointPrefix_opListVariantImportJobsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListVariantImportJobsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListVariantImportJobsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListVariantImportJobsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListVariantImportJobsAPIClient is a client that implements the
// ListVariantImportJobs operation.
type ListVariantImportJobsAPIClient interface {
ListVariantImportJobs(context.Context, *ListVariantImportJobsInput, ...func(*Options)) (*ListVariantImportJobsOutput, error)
}
var _ ListVariantImportJobsAPIClient = (*Client)(nil)
// ListVariantImportJobsPaginatorOptions is the paginator options for
// ListVariantImportJobs
type ListVariantImportJobsPaginatorOptions struct {
// The maximum number of import jobs to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListVariantImportJobsPaginator is a paginator for ListVariantImportJobs
type ListVariantImportJobsPaginator struct {
options ListVariantImportJobsPaginatorOptions
client ListVariantImportJobsAPIClient
params *ListVariantImportJobsInput
nextToken *string
firstPage bool
}
// NewListVariantImportJobsPaginator returns a new ListVariantImportJobsPaginator
func NewListVariantImportJobsPaginator(client ListVariantImportJobsAPIClient, params *ListVariantImportJobsInput, optFns ...func(*ListVariantImportJobsPaginatorOptions)) *ListVariantImportJobsPaginator {
if params == nil {
params = &ListVariantImportJobsInput{}
}
options := ListVariantImportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListVariantImportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListVariantImportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListVariantImportJobs page.
func (p *ListVariantImportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListVariantImportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListVariantImportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListVariantImportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListVariantImportJobs",
}
}
| 255 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of variant stores.
func (c *Client) ListVariantStores(ctx context.Context, params *ListVariantStoresInput, optFns ...func(*Options)) (*ListVariantStoresOutput, error) {
if params == nil {
params = &ListVariantStoresInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListVariantStores", params, optFns, c.addOperationListVariantStoresMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListVariantStoresOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListVariantStoresInput struct {
// A filter to apply to the list.
Filter *types.ListVariantStoresFilter
// A list of store IDs.
Ids []string
// The maximum number of stores to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListVariantStoresOutput struct {
// A pagination token that's included if more results are available.
NextToken *string
// A list of variant stores.
VariantStores []types.VariantStoreItem
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListVariantStoresMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListVariantStores{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListVariantStores{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListVariantStoresMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListVariantStores(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListVariantStoresMiddleware struct {
}
func (*endpointPrefix_opListVariantStoresMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListVariantStoresMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListVariantStoresMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListVariantStoresMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListVariantStoresAPIClient is a client that implements the ListVariantStores
// operation.
type ListVariantStoresAPIClient interface {
ListVariantStores(context.Context, *ListVariantStoresInput, ...func(*Options)) (*ListVariantStoresOutput, error)
}
var _ ListVariantStoresAPIClient = (*Client)(nil)
// ListVariantStoresPaginatorOptions is the paginator options for ListVariantStores
type ListVariantStoresPaginatorOptions struct {
// The maximum number of stores to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListVariantStoresPaginator is a paginator for ListVariantStores
type ListVariantStoresPaginator struct {
options ListVariantStoresPaginatorOptions
client ListVariantStoresAPIClient
params *ListVariantStoresInput
nextToken *string
firstPage bool
}
// NewListVariantStoresPaginator returns a new ListVariantStoresPaginator
func NewListVariantStoresPaginator(client ListVariantStoresAPIClient, params *ListVariantStoresInput, optFns ...func(*ListVariantStoresPaginatorOptions)) *ListVariantStoresPaginator {
if params == nil {
params = &ListVariantStoresInput{}
}
options := ListVariantStoresPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListVariantStoresPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListVariantStoresPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListVariantStores page.
func (p *ListVariantStoresPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListVariantStoresOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListVariantStores(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListVariantStores(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListVariantStores",
}
}
| 254 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of workflows.
func (c *Client) ListWorkflows(ctx context.Context, params *ListWorkflowsInput, optFns ...func(*Options)) (*ListWorkflowsOutput, error) {
if params == nil {
params = &ListWorkflowsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListWorkflows", params, optFns, c.addOperationListWorkflowsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListWorkflowsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListWorkflowsInput struct {
// The maximum number of workflows to return in one page of results.
MaxResults *int32
// The workflows' name.
Name *string
// Specify the pagination token from a previous request to retrieve the next page
// of results.
StartingToken *string
// The workflows' type.
Type types.WorkflowType
noSmithyDocumentSerde
}
type ListWorkflowsOutput struct {
// The workflows' items.
Items []types.WorkflowListItem
// A pagination token that's included if more results are available.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListWorkflowsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListWorkflows{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListWorkflows{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opListWorkflowsMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListWorkflows(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opListWorkflowsMiddleware struct {
}
func (*endpointPrefix_opListWorkflowsMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opListWorkflowsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opListWorkflowsMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opListWorkflowsMiddleware{}, `OperationSerializer`, middleware.After)
}
// ListWorkflowsAPIClient is a client that implements the ListWorkflows operation.
type ListWorkflowsAPIClient interface {
ListWorkflows(context.Context, *ListWorkflowsInput, ...func(*Options)) (*ListWorkflowsOutput, error)
}
var _ ListWorkflowsAPIClient = (*Client)(nil)
// ListWorkflowsPaginatorOptions is the paginator options for ListWorkflows
type ListWorkflowsPaginatorOptions struct {
// The maximum number of workflows to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListWorkflowsPaginator is a paginator for ListWorkflows
type ListWorkflowsPaginator struct {
options ListWorkflowsPaginatorOptions
client ListWorkflowsAPIClient
params *ListWorkflowsInput
nextToken *string
firstPage bool
}
// NewListWorkflowsPaginator returns a new ListWorkflowsPaginator
func NewListWorkflowsPaginator(client ListWorkflowsAPIClient, params *ListWorkflowsInput, optFns ...func(*ListWorkflowsPaginatorOptions)) *ListWorkflowsPaginator {
if params == nil {
params = &ListWorkflowsInput{}
}
options := ListWorkflowsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListWorkflowsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.StartingToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListWorkflowsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListWorkflows page.
func (p *ListWorkflowsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListWorkflowsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.StartingToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListWorkflows(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListWorkflows(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "ListWorkflows",
}
}
| 253 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts an annotation import job.
func (c *Client) StartAnnotationImportJob(ctx context.Context, params *StartAnnotationImportJobInput, optFns ...func(*Options)) (*StartAnnotationImportJobOutput, error) {
if params == nil {
params = &StartAnnotationImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartAnnotationImportJob", params, optFns, c.addOperationStartAnnotationImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartAnnotationImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartAnnotationImportJobInput struct {
// A destination annotation store for the job.
//
// This member is required.
DestinationName *string
// Items to import.
//
// This member is required.
Items []types.AnnotationImportItemSource
// A service role for the job.
//
// This member is required.
RoleArn *string
// The annotation schema generated by the parsed annotation data.
AnnotationFields map[string]string
// Formatting options for the annotation file.
FormatOptions types.FormatOptions
// The job's left normalization setting.
RunLeftNormalization bool
noSmithyDocumentSerde
}
type StartAnnotationImportJobOutput struct {
// The job's ID.
//
// This member is required.
JobId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartAnnotationImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartAnnotationImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartAnnotationImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opStartAnnotationImportJobMiddleware(stack); err != nil {
return err
}
if err = addOpStartAnnotationImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartAnnotationImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opStartAnnotationImportJobMiddleware struct {
}
func (*endpointPrefix_opStartAnnotationImportJobMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opStartAnnotationImportJobMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opStartAnnotationImportJobMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opStartAnnotationImportJobMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opStartAnnotationImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "StartAnnotationImportJob",
}
}
| 177 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Activates an archived read set. To reduce storage charges, Amazon Omics
// archives unused read sets after 30 days.
func (c *Client) StartReadSetActivationJob(ctx context.Context, params *StartReadSetActivationJobInput, optFns ...func(*Options)) (*StartReadSetActivationJobOutput, error) {
if params == nil {
params = &StartReadSetActivationJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartReadSetActivationJob", params, optFns, c.addOperationStartReadSetActivationJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartReadSetActivationJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartReadSetActivationJobInput struct {
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's source files.
//
// This member is required.
Sources []types.StartReadSetActivationJobSourceItem
// To ensure that jobs don't run multiple times, specify a unique token for each
// job.
ClientToken *string
noSmithyDocumentSerde
}
type StartReadSetActivationJobOutput struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's ID.
//
// This member is required.
Id *string
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's status.
//
// This member is required.
Status types.ReadSetActivationJobStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartReadSetActivationJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartReadSetActivationJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartReadSetActivationJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opStartReadSetActivationJobMiddleware(stack); err != nil {
return err
}
if err = addOpStartReadSetActivationJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartReadSetActivationJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opStartReadSetActivationJobMiddleware struct {
}
func (*endpointPrefix_opStartReadSetActivationJobMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opStartReadSetActivationJobMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opStartReadSetActivationJobMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opStartReadSetActivationJobMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opStartReadSetActivationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "StartReadSetActivationJob",
}
}
| 184 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Exports a read set to Amazon S3.
func (c *Client) StartReadSetExportJob(ctx context.Context, params *StartReadSetExportJobInput, optFns ...func(*Options)) (*StartReadSetExportJobOutput, error) {
if params == nil {
params = &StartReadSetExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartReadSetExportJob", params, optFns, c.addOperationStartReadSetExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartReadSetExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartReadSetExportJobInput struct {
// A location for exported files in Amazon S3.
//
// This member is required.
Destination *string
// A service role for the job.
//
// This member is required.
RoleArn *string
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's source files.
//
// This member is required.
Sources []types.ExportReadSet
// To ensure that jobs don't run multiple times, specify a unique token for each
// job.
ClientToken *string
noSmithyDocumentSerde
}
type StartReadSetExportJobOutput struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's output location.
//
// This member is required.
Destination *string
// The job's ID.
//
// This member is required.
Id *string
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's status.
//
// This member is required.
Status types.ReadSetExportJobStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartReadSetExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartReadSetExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartReadSetExportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opStartReadSetExportJobMiddleware(stack); err != nil {
return err
}
if err = addOpStartReadSetExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartReadSetExportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opStartReadSetExportJobMiddleware struct {
}
func (*endpointPrefix_opStartReadSetExportJobMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opStartReadSetExportJobMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opStartReadSetExportJobMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opStartReadSetExportJobMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opStartReadSetExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "StartReadSetExportJob",
}
}
| 198 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Starts a read set import job.
func (c *Client) StartReadSetImportJob(ctx context.Context, params *StartReadSetImportJobInput, optFns ...func(*Options)) (*StartReadSetImportJobOutput, error) {
if params == nil {
params = &StartReadSetImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartReadSetImportJob", params, optFns, c.addOperationStartReadSetImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartReadSetImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartReadSetImportJobInput struct {
// A service role for the job.
//
// This member is required.
RoleArn *string
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's source files.
//
// This member is required.
Sources []types.StartReadSetImportJobSourceItem
// To ensure that jobs don't run multiple times, specify a unique token for each
// job.
ClientToken *string
noSmithyDocumentSerde
}
type StartReadSetImportJobOutput struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's ID.
//
// This member is required.
Id *string
// The job's service role ARN.
//
// This member is required.
RoleArn *string
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's status.
//
// This member is required.
Status types.ReadSetImportJobStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartReadSetImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartReadSetImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartReadSetImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opStartReadSetImportJobMiddleware(stack); err != nil {
return err
}
if err = addOpStartReadSetImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartReadSetImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opStartReadSetImportJobMiddleware struct {
}
func (*endpointPrefix_opStartReadSetImportJobMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opStartReadSetImportJobMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opStartReadSetImportJobMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opStartReadSetImportJobMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opStartReadSetImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "StartReadSetImportJob",
}
}
| 193 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Starts a reference import job.
func (c *Client) StartReferenceImportJob(ctx context.Context, params *StartReferenceImportJobInput, optFns ...func(*Options)) (*StartReferenceImportJobOutput, error) {
if params == nil {
params = &StartReferenceImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartReferenceImportJob", params, optFns, c.addOperationStartReferenceImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartReferenceImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartReferenceImportJobInput struct {
// The job's reference store ID.
//
// This member is required.
ReferenceStoreId *string
// A service role for the job.
//
// This member is required.
RoleArn *string
// The job's source files.
//
// This member is required.
Sources []types.StartReferenceImportJobSourceItem
// To ensure that jobs don't run multiple times, specify a unique token for each
// job.
ClientToken *string
noSmithyDocumentSerde
}
type StartReferenceImportJobOutput struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's ID.
//
// This member is required.
Id *string
// The job's reference store ID.
//
// This member is required.
ReferenceStoreId *string
// The job's service role ARN.
//
// This member is required.
RoleArn *string
// The job's status.
//
// This member is required.
Status types.ReferenceImportJobStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartReferenceImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartReferenceImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartReferenceImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opStartReferenceImportJobMiddleware(stack); err != nil {
return err
}
if err = addOpStartReferenceImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartReferenceImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opStartReferenceImportJobMiddleware struct {
}
func (*endpointPrefix_opStartReferenceImportJobMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opStartReferenceImportJobMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "control-storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opStartReferenceImportJobMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opStartReferenceImportJobMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opStartReferenceImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "StartReferenceImportJob",
}
}
| 193 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/document"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a run.
func (c *Client) StartRun(ctx context.Context, params *StartRunInput, optFns ...func(*Options)) (*StartRunOutput, error) {
if params == nil {
params = &StartRunInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartRun", params, optFns, c.addOperationStartRunMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartRunOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartRunInput struct {
// To ensure that requests don't run multiple times, specify a unique ID for each
// request.
//
// This member is required.
RequestId *string
// A service role for the run.
//
// This member is required.
RoleArn *string
// A log level for the run.
LogLevel types.RunLogLevel
// A name for the run.
Name *string
// An output URI for the run.
OutputUri *string
// Parameters for the run.
Parameters document.Interface
// A priority for the run.
Priority *int32
// The run's group ID.
RunGroupId *string
// The run's ID.
RunId *string
// A storage capacity for the run in gigabytes.
StorageCapacity *int32
// Tags for the run.
Tags map[string]string
// The run's workflow ID.
WorkflowId *string
// The run's workflows type.
WorkflowType types.WorkflowType
noSmithyDocumentSerde
}
type StartRunOutput struct {
// The run's ARN.
Arn *string
// The run's ID.
Id *string
// The run's status.
Status types.RunStatus
// The run's tags.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartRunMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartRun{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartRun{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opStartRunMiddleware(stack); err != nil {
return err
}
if err = addIdempotencyToken_opStartRunMiddleware(stack, options); err != nil {
return err
}
if err = addOpStartRunValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartRun(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opStartRunMiddleware struct {
}
func (*endpointPrefix_opStartRunMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opStartRunMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opStartRunMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opStartRunMiddleware{}, `OperationSerializer`, middleware.After)
}
type idempotencyToken_initializeOpStartRun struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpStartRun) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpStartRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*StartRunInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *StartRunInput ")
}
if input.RequestId == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.RequestId = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opStartRunMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpStartRun{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opStartRun(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "StartRun",
}
}
| 241 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a variant import job.
func (c *Client) StartVariantImportJob(ctx context.Context, params *StartVariantImportJobInput, optFns ...func(*Options)) (*StartVariantImportJobOutput, error) {
if params == nil {
params = &StartVariantImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartVariantImportJob", params, optFns, c.addOperationStartVariantImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartVariantImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartVariantImportJobInput struct {
// The destination variant store for the job.
//
// This member is required.
DestinationName *string
// Items to import.
//
// This member is required.
Items []types.VariantImportItemSource
// A service role for the job.
//
// This member is required.
RoleArn *string
// The annotation schema generated by the parsed annotation data.
AnnotationFields map[string]string
// The job's left normalization setting.
RunLeftNormalization bool
noSmithyDocumentSerde
}
type StartVariantImportJobOutput struct {
// The job's ID.
//
// This member is required.
JobId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartVariantImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartVariantImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartVariantImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opStartVariantImportJobMiddleware(stack); err != nil {
return err
}
if err = addOpStartVariantImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartVariantImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opStartVariantImportJobMiddleware struct {
}
func (*endpointPrefix_opStartVariantImportJobMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opStartVariantImportJobMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opStartVariantImportJobMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opStartVariantImportJobMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opStartVariantImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "StartVariantImportJob",
}
}
| 174 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Tags a resource.
func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error) {
if params == nil {
params = &TagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "TagResource", params, optFns, c.addOperationTagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*TagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type TagResourceInput struct {
// The resource's ARN.
//
// This member is required.
ResourceArn *string
// Tags for the resource.
//
// This member is required.
Tags map[string]string
noSmithyDocumentSerde
}
type TagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opTagResourceMiddleware(stack); err != nil {
return err
}
if err = addOpTagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opTagResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opTagResourceMiddleware struct {
}
func (*endpointPrefix_opTagResourceMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opTagResourceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "tags-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opTagResourceMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opTagResourceMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opTagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "TagResource",
}
}
| 156 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes tags from a resource.
func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error) {
if params == nil {
params = &UntagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UntagResource", params, optFns, c.addOperationUntagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UntagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UntagResourceInput struct {
// The resource's ARN.
//
// This member is required.
ResourceArn *string
// Keys of tags to remove.
//
// This member is required.
TagKeys []string
noSmithyDocumentSerde
}
type UntagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opUntagResourceMiddleware(stack); err != nil {
return err
}
if err = addOpUntagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUntagResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opUntagResourceMiddleware struct {
}
func (*endpointPrefix_opUntagResourceMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opUntagResourceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "tags-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opUntagResourceMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opUntagResourceMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opUntagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "UntagResource",
}
}
| 156 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates an annotation store.
func (c *Client) UpdateAnnotationStore(ctx context.Context, params *UpdateAnnotationStoreInput, optFns ...func(*Options)) (*UpdateAnnotationStoreOutput, error) {
if params == nil {
params = &UpdateAnnotationStoreInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateAnnotationStore", params, optFns, c.addOperationUpdateAnnotationStoreMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateAnnotationStoreOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateAnnotationStoreInput struct {
// A name for the store.
//
// This member is required.
Name *string
// A description for the store.
Description *string
noSmithyDocumentSerde
}
type UpdateAnnotationStoreOutput struct {
// When the store was created.
//
// This member is required.
CreationTime *time.Time
// The store's description.
//
// This member is required.
Description *string
// The store's ID.
//
// This member is required.
Id *string
// The store's name.
//
// This member is required.
Name *string
// The store's genome reference.
//
// This member is required.
Reference types.ReferenceItem
// The store's status.
//
// This member is required.
Status types.StoreStatus
// When the store was updated.
//
// This member is required.
UpdateTime *time.Time
// The annotation file format of the store.
StoreFormat types.StoreFormat
// Parsing options for the store.
StoreOptions types.StoreOptions
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateAnnotationStoreMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateAnnotationStore{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateAnnotationStore{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opUpdateAnnotationStoreMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateAnnotationStoreValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateAnnotationStore(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opUpdateAnnotationStoreMiddleware struct {
}
func (*endpointPrefix_opUpdateAnnotationStoreMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opUpdateAnnotationStoreMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opUpdateAnnotationStoreMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opUpdateAnnotationStoreMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opUpdateAnnotationStore(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "UpdateAnnotationStore",
}
}
| 198 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates a run group.
func (c *Client) UpdateRunGroup(ctx context.Context, params *UpdateRunGroupInput, optFns ...func(*Options)) (*UpdateRunGroupOutput, error) {
if params == nil {
params = &UpdateRunGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateRunGroup", params, optFns, c.addOperationUpdateRunGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateRunGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateRunGroupInput struct {
// The group's ID.
//
// This member is required.
Id *string
// The maximum number of CPUs to use.
MaxCpus *int32
// A maximum run time for the group in minutes.
MaxDuration *int32
// The maximum GPUs that can be used by a run group.
MaxGpus *int32
// The maximum number of concurrent runs for the group.
MaxRuns *int32
// A name for the group.
Name *string
noSmithyDocumentSerde
}
type UpdateRunGroupOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateRunGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateRunGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateRunGroup{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opUpdateRunGroupMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateRunGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateRunGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opUpdateRunGroupMiddleware struct {
}
func (*endpointPrefix_opUpdateRunGroupMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opUpdateRunGroupMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opUpdateRunGroupMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opUpdateRunGroupMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opUpdateRunGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "UpdateRunGroup",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates a variant store.
func (c *Client) UpdateVariantStore(ctx context.Context, params *UpdateVariantStoreInput, optFns ...func(*Options)) (*UpdateVariantStoreOutput, error) {
if params == nil {
params = &UpdateVariantStoreInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateVariantStore", params, optFns, c.addOperationUpdateVariantStoreMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateVariantStoreOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateVariantStoreInput struct {
// A name for the store.
//
// This member is required.
Name *string
// A description for the store.
Description *string
noSmithyDocumentSerde
}
type UpdateVariantStoreOutput struct {
// When the store was created.
//
// This member is required.
CreationTime *time.Time
// The store's description.
//
// This member is required.
Description *string
// The store's ID.
//
// This member is required.
Id *string
// The store's name.
//
// This member is required.
Name *string
// The store's genome reference.
//
// This member is required.
Reference types.ReferenceItem
// The store's status.
//
// This member is required.
Status types.StoreStatus
// When the store was updated.
//
// This member is required.
UpdateTime *time.Time
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateVariantStoreMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateVariantStore{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateVariantStore{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opUpdateVariantStoreMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateVariantStoreValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateVariantStore(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opUpdateVariantStoreMiddleware struct {
}
func (*endpointPrefix_opUpdateVariantStoreMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opUpdateVariantStoreMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "analytics-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opUpdateVariantStoreMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opUpdateVariantStoreMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opUpdateVariantStore(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "UpdateVariantStore",
}
}
| 192 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates a workflow.
func (c *Client) UpdateWorkflow(ctx context.Context, params *UpdateWorkflowInput, optFns ...func(*Options)) (*UpdateWorkflowOutput, error) {
if params == nil {
params = &UpdateWorkflowInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateWorkflow", params, optFns, c.addOperationUpdateWorkflowMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateWorkflowOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateWorkflowInput struct {
// The workflow's ID.
//
// This member is required.
Id *string
// A description for the workflow.
Description *string
// A name for the workflow.
Name *string
noSmithyDocumentSerde
}
type UpdateWorkflowOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateWorkflowMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateWorkflow{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateWorkflow{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opUpdateWorkflowMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateWorkflowValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateWorkflow(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opUpdateWorkflowMiddleware struct {
}
func (*endpointPrefix_opUpdateWorkflowMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opUpdateWorkflowMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "workflows-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opUpdateWorkflowMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opUpdateWorkflowMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opUpdateWorkflow(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "UpdateWorkflow",
}
}
| 157 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
)
// This operation uploads a specific part of a read set. If you upload a new part
// using a previously used part number, the previously uploaded part will be
// overwritten.
func (c *Client) UploadReadSetPart(ctx context.Context, params *UploadReadSetPartInput, optFns ...func(*Options)) (*UploadReadSetPartOutput, error) {
if params == nil {
params = &UploadReadSetPartInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UploadReadSetPart", params, optFns, c.addOperationUploadReadSetPartMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UploadReadSetPartOutput)
out.ResultMetadata = metadata
return out, nil
}
type UploadReadSetPartInput struct {
// The number of the part being uploaded.
//
// This member is required.
PartNumber *int32
// The source file for an upload part.
//
// This member is required.
PartSource types.ReadSetPartSource
// The read set data to upload for a part.
//
// This member is required.
Payload io.Reader
// The Sequence Store ID used for the multipart upload.
//
// This member is required.
SequenceStoreId *string
// The ID for the initiated multipart upload.
//
// This member is required.
UploadId *string
noSmithyDocumentSerde
}
type UploadReadSetPartOutput struct {
// An identifier used to confirm that parts are being added to the intended upload.
//
// This member is required.
Checksum *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUploadReadSetPartMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUploadReadSetPart{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUploadReadSetPart{}, 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.AddUnsignedPayloadMiddleware(stack); err != nil {
return err
}
if err = v4.AddContentSHA256HeaderMiddleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addEndpointPrefix_opUploadReadSetPartMiddleware(stack); err != nil {
return err
}
if err = addOpUploadReadSetPartValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUploadReadSetPart(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type endpointPrefix_opUploadReadSetPartMiddleware struct {
}
func (*endpointPrefix_opUploadReadSetPartMiddleware) ID() string {
return "EndpointHostPrefix"
}
func (m *endpointPrefix_opUploadReadSetPartMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) {
return next.HandleSerialize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
req.URL.Host = "storage-" + req.URL.Host
return next.HandleSerialize(ctx, in)
}
func addEndpointPrefix_opUploadReadSetPartMiddleware(stack *middleware.Stack) error {
return stack.Serialize.Insert(&endpointPrefix_opUploadReadSetPartMiddleware{}, `OperationSerializer`, middleware.After)
}
func newServiceMetadataMiddleware_opUploadReadSetPart(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "omics",
OperationName: "UploadReadSetPart",
}
}
| 184 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package omics provides the API client, operations, and parameter types for
// Amazon Omics.
//
// This is the Amazon Omics API Reference. For an introduction to the service, see
// What is Amazon Omics? (https://docs.aws.amazon.com/omics/latest/dev/) in the
// Amazon Omics User Guide.
package omics
| 10 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/omics/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 = "omics"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package omics
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.5.0"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/omics/document"
internaldocument "github.com/aws/aws-sdk-go-v2/service/omics/internal/document"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
type awsRestjson1_serializeOpAbortMultipartReadSetUpload struct {
}
func (*awsRestjson1_serializeOpAbortMultipartReadSetUpload) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAbortMultipartReadSetUpload) 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.(*AbortMultipartReadSetUploadInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/upload/{uploadId}/abort")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsAbortMultipartReadSetUploadInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsAbortMultipartReadSetUploadInput(v *AbortMultipartReadSetUploadInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
if v.UploadId == nil || len(*v.UploadId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member uploadId must not be empty")}
}
if v.UploadId != nil {
if err := encoder.SetURI("uploadId").String(*v.UploadId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchDeleteReadSet struct {
}
func (*awsRestjson1_serializeOpBatchDeleteReadSet) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchDeleteReadSet) 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.(*BatchDeleteReadSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/readset/batch/delete")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsBatchDeleteReadSetInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentBatchDeleteReadSetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsBatchDeleteReadSetInput(v *BatchDeleteReadSetInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchDeleteReadSetInput(v *BatchDeleteReadSetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Ids != nil {
ok := object.Key("ids")
if err := awsRestjson1_serializeDocumentReadSetIdList(v.Ids, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCancelAnnotationImportJob struct {
}
func (*awsRestjson1_serializeOpCancelAnnotationImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCancelAnnotationImportJob) 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.(*CancelAnnotationImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/import/annotation/{jobId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsCancelAnnotationImportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCancelAnnotationImportJobInput(v *CancelAnnotationImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.JobId == nil || len(*v.JobId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member jobId must not be empty")}
}
if v.JobId != nil {
if err := encoder.SetURI("jobId").String(*v.JobId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCancelRun struct {
}
func (*awsRestjson1_serializeOpCancelRun) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCancelRun) 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.(*CancelRunInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/run/{id}/cancel")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsCancelRunInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCancelRunInput(v *CancelRunInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCancelVariantImportJob struct {
}
func (*awsRestjson1_serializeOpCancelVariantImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCancelVariantImportJob) 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.(*CancelVariantImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/import/variant/{jobId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsCancelVariantImportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCancelVariantImportJobInput(v *CancelVariantImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.JobId == nil || len(*v.JobId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member jobId must not be empty")}
}
if v.JobId != nil {
if err := encoder.SetURI("jobId").String(*v.JobId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCompleteMultipartReadSetUpload struct {
}
func (*awsRestjson1_serializeOpCompleteMultipartReadSetUpload) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCompleteMultipartReadSetUpload) 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.(*CompleteMultipartReadSetUploadInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/upload/{uploadId}/complete")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsCompleteMultipartReadSetUploadInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCompleteMultipartReadSetUploadInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCompleteMultipartReadSetUploadInput(v *CompleteMultipartReadSetUploadInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
if v.UploadId == nil || len(*v.UploadId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member uploadId must not be empty")}
}
if v.UploadId != nil {
if err := encoder.SetURI("uploadId").String(*v.UploadId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCompleteMultipartReadSetUploadInput(v *CompleteMultipartReadSetUploadInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Parts != nil {
ok := object.Key("parts")
if err := awsRestjson1_serializeDocumentCompleteReadSetUploadPartList(v.Parts, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateAnnotationStore struct {
}
func (*awsRestjson1_serializeOpCreateAnnotationStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateAnnotationStore) 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.(*CreateAnnotationStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/annotationStore")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateAnnotationStoreInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateAnnotationStoreInput(v *CreateAnnotationStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateAnnotationStoreInput(v *CreateAnnotationStoreInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.Reference != nil {
ok := object.Key("reference")
if err := awsRestjson1_serializeDocumentReferenceItem(v.Reference, ok); err != nil {
return err
}
}
if v.SseConfig != nil {
ok := object.Key("sseConfig")
if err := awsRestjson1_serializeDocumentSseConfig(v.SseConfig, ok); err != nil {
return err
}
}
if len(v.StoreFormat) > 0 {
ok := object.Key("storeFormat")
ok.String(string(v.StoreFormat))
}
if v.StoreOptions != nil {
ok := object.Key("storeOptions")
if err := awsRestjson1_serializeDocumentStoreOptions(v.StoreOptions, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateMultipartReadSetUpload struct {
}
func (*awsRestjson1_serializeOpCreateMultipartReadSetUpload) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateMultipartReadSetUpload) 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.(*CreateMultipartReadSetUploadInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/upload")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsCreateMultipartReadSetUploadInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateMultipartReadSetUploadInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateMultipartReadSetUploadInput(v *CreateMultipartReadSetUploadInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateMultipartReadSetUploadInput(v *CreateMultipartReadSetUploadInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.GeneratedFrom != nil {
ok := object.Key("generatedFrom")
ok.String(*v.GeneratedFrom)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.ReferenceArn != nil {
ok := object.Key("referenceArn")
ok.String(*v.ReferenceArn)
}
if v.SampleId != nil {
ok := object.Key("sampleId")
ok.String(*v.SampleId)
}
if len(v.SourceFileType) > 0 {
ok := object.Key("sourceFileType")
ok.String(string(v.SourceFileType))
}
if v.SubjectId != nil {
ok := object.Key("subjectId")
ok.String(*v.SubjectId)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateReferenceStore struct {
}
func (*awsRestjson1_serializeOpCreateReferenceStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateReferenceStore) 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.(*CreateReferenceStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateReferenceStoreInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateReferenceStoreInput(v *CreateReferenceStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateReferenceStoreInput(v *CreateReferenceStoreInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.SseConfig != nil {
ok := object.Key("sseConfig")
if err := awsRestjson1_serializeDocumentSseConfig(v.SseConfig, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateRunGroup struct {
}
func (*awsRestjson1_serializeOpCreateRunGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateRunGroup) 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.(*CreateRunGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/runGroup")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateRunGroupInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateRunGroupInput(v *CreateRunGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateRunGroupInput(v *CreateRunGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxCpus != nil {
ok := object.Key("maxCpus")
ok.Integer(*v.MaxCpus)
}
if v.MaxDuration != nil {
ok := object.Key("maxDuration")
ok.Integer(*v.MaxDuration)
}
if v.MaxGpus != nil {
ok := object.Key("maxGpus")
ok.Integer(*v.MaxGpus)
}
if v.MaxRuns != nil {
ok := object.Key("maxRuns")
ok.Integer(*v.MaxRuns)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.RequestId != nil {
ok := object.Key("requestId")
ok.String(*v.RequestId)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateSequenceStore struct {
}
func (*awsRestjson1_serializeOpCreateSequenceStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateSequenceStore) 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.(*CreateSequenceStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateSequenceStoreInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateSequenceStoreInput(v *CreateSequenceStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateSequenceStoreInput(v *CreateSequenceStoreInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.FallbackLocation != nil {
ok := object.Key("fallbackLocation")
ok.String(*v.FallbackLocation)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.SseConfig != nil {
ok := object.Key("sseConfig")
if err := awsRestjson1_serializeDocumentSseConfig(v.SseConfig, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateVariantStore struct {
}
func (*awsRestjson1_serializeOpCreateVariantStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateVariantStore) 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.(*CreateVariantStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/variantStore")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateVariantStoreInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateVariantStoreInput(v *CreateVariantStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateVariantStoreInput(v *CreateVariantStoreInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.Reference != nil {
ok := object.Key("reference")
if err := awsRestjson1_serializeDocumentReferenceItem(v.Reference, ok); err != nil {
return err
}
}
if v.SseConfig != nil {
ok := object.Key("sseConfig")
if err := awsRestjson1_serializeDocumentSseConfig(v.SseConfig, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateWorkflow struct {
}
func (*awsRestjson1_serializeOpCreateWorkflow) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateWorkflow) 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.(*CreateWorkflowInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/workflow")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateWorkflowInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsCreateWorkflowInput(v *CreateWorkflowInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateWorkflowInput(v *CreateWorkflowInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Accelerators) > 0 {
ok := object.Key("accelerators")
ok.String(string(v.Accelerators))
}
if v.DefinitionUri != nil {
ok := object.Key("definitionUri")
ok.String(*v.DefinitionUri)
}
if v.DefinitionZip != nil {
ok := object.Key("definitionZip")
ok.Base64EncodeBytes(v.DefinitionZip)
}
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if len(v.Engine) > 0 {
ok := object.Key("engine")
ok.String(string(v.Engine))
}
if v.Main != nil {
ok := object.Key("main")
ok.String(*v.Main)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.ParameterTemplate != nil {
ok := object.Key("parameterTemplate")
if err := awsRestjson1_serializeDocumentWorkflowParameterTemplate(v.ParameterTemplate, ok); err != nil {
return err
}
}
if v.RequestId != nil {
ok := object.Key("requestId")
ok.String(*v.RequestId)
}
if v.StorageCapacity != nil {
ok := object.Key("storageCapacity")
ok.Integer(*v.StorageCapacity)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteAnnotationStore struct {
}
func (*awsRestjson1_serializeOpDeleteAnnotationStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteAnnotationStore) 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.(*DeleteAnnotationStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/annotationStore/{name}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteAnnotationStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteAnnotationStoreInput(v *DeleteAnnotationStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Force {
encoder.SetQuery("force").Boolean(v.Force)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("name").String(*v.Name); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteReference struct {
}
func (*awsRestjson1_serializeOpDeleteReference) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteReference) 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.(*DeleteReferenceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{referenceStoreId}/reference/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteReferenceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteReferenceInput(v *DeleteReferenceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.ReferenceStoreId == nil || len(*v.ReferenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member referenceStoreId must not be empty")}
}
if v.ReferenceStoreId != nil {
if err := encoder.SetURI("referenceStoreId").String(*v.ReferenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteReferenceStore struct {
}
func (*awsRestjson1_serializeOpDeleteReferenceStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteReferenceStore) 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.(*DeleteReferenceStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteReferenceStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteReferenceStoreInput(v *DeleteReferenceStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteRun struct {
}
func (*awsRestjson1_serializeOpDeleteRun) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteRun) 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.(*DeleteRunInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/run/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteRunInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteRunInput(v *DeleteRunInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteRunGroup struct {
}
func (*awsRestjson1_serializeOpDeleteRunGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteRunGroup) 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.(*DeleteRunGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/runGroup/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteRunGroupInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteRunGroupInput(v *DeleteRunGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteSequenceStore struct {
}
func (*awsRestjson1_serializeOpDeleteSequenceStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteSequenceStore) 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.(*DeleteSequenceStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteSequenceStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteSequenceStoreInput(v *DeleteSequenceStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteVariantStore struct {
}
func (*awsRestjson1_serializeOpDeleteVariantStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteVariantStore) 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.(*DeleteVariantStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/variantStore/{name}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteVariantStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteVariantStoreInput(v *DeleteVariantStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Force {
encoder.SetQuery("force").Boolean(v.Force)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("name").String(*v.Name); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteWorkflow struct {
}
func (*awsRestjson1_serializeOpDeleteWorkflow) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteWorkflow) 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.(*DeleteWorkflowInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/workflow/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteWorkflowInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDeleteWorkflowInput(v *DeleteWorkflowInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetAnnotationImportJob struct {
}
func (*awsRestjson1_serializeOpGetAnnotationImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetAnnotationImportJob) 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.(*GetAnnotationImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/import/annotation/{jobId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetAnnotationImportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetAnnotationImportJobInput(v *GetAnnotationImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.JobId == nil || len(*v.JobId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member jobId must not be empty")}
}
if v.JobId != nil {
if err := encoder.SetURI("jobId").String(*v.JobId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetAnnotationStore struct {
}
func (*awsRestjson1_serializeOpGetAnnotationStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetAnnotationStore) 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.(*GetAnnotationStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/annotationStore/{name}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetAnnotationStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetAnnotationStoreInput(v *GetAnnotationStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("name").String(*v.Name); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReadSet struct {
}
func (*awsRestjson1_serializeOpGetReadSet) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReadSet) 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.(*GetReadSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/readset/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReadSetInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReadSetInput(v *GetReadSetInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.File) > 0 {
encoder.SetQuery("file").String(string(v.File))
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.PartNumber != nil {
encoder.SetQuery("partNumber").Integer(*v.PartNumber)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReadSetActivationJob struct {
}
func (*awsRestjson1_serializeOpGetReadSetActivationJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReadSetActivationJob) 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.(*GetReadSetActivationJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/activationjob/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReadSetActivationJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReadSetActivationJobInput(v *GetReadSetActivationJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReadSetExportJob struct {
}
func (*awsRestjson1_serializeOpGetReadSetExportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReadSetExportJob) 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.(*GetReadSetExportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/exportjob/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReadSetExportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReadSetExportJobInput(v *GetReadSetExportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReadSetImportJob struct {
}
func (*awsRestjson1_serializeOpGetReadSetImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReadSetImportJob) 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.(*GetReadSetImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/importjob/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReadSetImportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReadSetImportJobInput(v *GetReadSetImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReadSetMetadata struct {
}
func (*awsRestjson1_serializeOpGetReadSetMetadata) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReadSetMetadata) 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.(*GetReadSetMetadataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/readset/{id}/metadata")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReadSetMetadataInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReadSetMetadataInput(v *GetReadSetMetadataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReference struct {
}
func (*awsRestjson1_serializeOpGetReference) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReference) 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.(*GetReferenceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{referenceStoreId}/reference/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReferenceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReferenceInput(v *GetReferenceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.File) > 0 {
encoder.SetQuery("file").String(string(v.File))
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.PartNumber != nil {
encoder.SetQuery("partNumber").Integer(*v.PartNumber)
}
if v.Range != nil && len(*v.Range) > 0 {
locationName := "Range"
encoder.SetHeader(locationName).String(*v.Range)
}
if v.ReferenceStoreId == nil || len(*v.ReferenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member referenceStoreId must not be empty")}
}
if v.ReferenceStoreId != nil {
if err := encoder.SetURI("referenceStoreId").String(*v.ReferenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReferenceImportJob struct {
}
func (*awsRestjson1_serializeOpGetReferenceImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReferenceImportJob) 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.(*GetReferenceImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{referenceStoreId}/importjob/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReferenceImportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReferenceImportJobInput(v *GetReferenceImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.ReferenceStoreId == nil || len(*v.ReferenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member referenceStoreId must not be empty")}
}
if v.ReferenceStoreId != nil {
if err := encoder.SetURI("referenceStoreId").String(*v.ReferenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReferenceMetadata struct {
}
func (*awsRestjson1_serializeOpGetReferenceMetadata) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReferenceMetadata) 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.(*GetReferenceMetadataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{referenceStoreId}/reference/{id}/metadata")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReferenceMetadataInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReferenceMetadataInput(v *GetReferenceMetadataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.ReferenceStoreId == nil || len(*v.ReferenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member referenceStoreId must not be empty")}
}
if v.ReferenceStoreId != nil {
if err := encoder.SetURI("referenceStoreId").String(*v.ReferenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetReferenceStore struct {
}
func (*awsRestjson1_serializeOpGetReferenceStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetReferenceStore) 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.(*GetReferenceStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetReferenceStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetReferenceStoreInput(v *GetReferenceStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetRun struct {
}
func (*awsRestjson1_serializeOpGetRun) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetRun) 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.(*GetRunInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/run/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetRunInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetRunInput(v *GetRunInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Export != nil {
for i := range v.Export {
encoder.AddQuery("export").String(string(v.Export[i]))
}
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetRunGroup struct {
}
func (*awsRestjson1_serializeOpGetRunGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetRunGroup) 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.(*GetRunGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/runGroup/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetRunGroupInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetRunGroupInput(v *GetRunGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetRunTask struct {
}
func (*awsRestjson1_serializeOpGetRunTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetRunTask) 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.(*GetRunTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/run/{id}/task/{taskId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetRunTaskInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetRunTaskInput(v *GetRunTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.TaskId == nil || len(*v.TaskId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member taskId must not be empty")}
}
if v.TaskId != nil {
if err := encoder.SetURI("taskId").String(*v.TaskId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetSequenceStore struct {
}
func (*awsRestjson1_serializeOpGetSequenceStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetSequenceStore) 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.(*GetSequenceStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetSequenceStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetSequenceStoreInput(v *GetSequenceStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetVariantImportJob struct {
}
func (*awsRestjson1_serializeOpGetVariantImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetVariantImportJob) 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.(*GetVariantImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/import/variant/{jobId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetVariantImportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetVariantImportJobInput(v *GetVariantImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.JobId == nil || len(*v.JobId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member jobId must not be empty")}
}
if v.JobId != nil {
if err := encoder.SetURI("jobId").String(*v.JobId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetVariantStore struct {
}
func (*awsRestjson1_serializeOpGetVariantStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetVariantStore) 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.(*GetVariantStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/variantStore/{name}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetVariantStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetVariantStoreInput(v *GetVariantStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("name").String(*v.Name); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetWorkflow struct {
}
func (*awsRestjson1_serializeOpGetWorkflow) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWorkflow) 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.(*GetWorkflowInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/workflow/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetWorkflowInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGetWorkflowInput(v *GetWorkflowInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Export != nil {
for i := range v.Export {
encoder.AddQuery("export").String(string(v.Export[i]))
}
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if len(v.Type) > 0 {
encoder.SetQuery("type").String(string(v.Type))
}
return nil
}
type awsRestjson1_serializeOpListAnnotationImportJobs struct {
}
func (*awsRestjson1_serializeOpListAnnotationImportJobs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListAnnotationImportJobs) 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.(*ListAnnotationImportJobsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/import/annotations")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListAnnotationImportJobsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListAnnotationImportJobsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListAnnotationImportJobsInput(v *ListAnnotationImportJobsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
func awsRestjson1_serializeOpDocumentListAnnotationImportJobsInput(v *ListAnnotationImportJobsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentListAnnotationImportJobsFilter(v.Filter, ok); err != nil {
return err
}
}
if v.Ids != nil {
ok := object.Key("ids")
if err := awsRestjson1_serializeDocumentIdList(v.Ids, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListAnnotationStores struct {
}
func (*awsRestjson1_serializeOpListAnnotationStores) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListAnnotationStores) 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.(*ListAnnotationStoresInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/annotationStores")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListAnnotationStoresInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListAnnotationStoresInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListAnnotationStoresInput(v *ListAnnotationStoresInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
func awsRestjson1_serializeOpDocumentListAnnotationStoresInput(v *ListAnnotationStoresInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentListAnnotationStoresFilter(v.Filter, ok); err != nil {
return err
}
}
if v.Ids != nil {
ok := object.Key("ids")
if err := awsRestjson1_serializeDocumentIdList(v.Ids, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListMultipartReadSetUploads struct {
}
func (*awsRestjson1_serializeOpListMultipartReadSetUploads) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListMultipartReadSetUploads) 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.(*ListMultipartReadSetUploadsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/uploads")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListMultipartReadSetUploadsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListMultipartReadSetUploadsInput(v *ListMultipartReadSetUploadsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListReadSetActivationJobs struct {
}
func (*awsRestjson1_serializeOpListReadSetActivationJobs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListReadSetActivationJobs) 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.(*ListReadSetActivationJobsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/activationjobs")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListReadSetActivationJobsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListReadSetActivationJobsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListReadSetActivationJobsInput(v *ListReadSetActivationJobsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentListReadSetActivationJobsInput(v *ListReadSetActivationJobsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentActivateReadSetFilter(v.Filter, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListReadSetExportJobs struct {
}
func (*awsRestjson1_serializeOpListReadSetExportJobs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListReadSetExportJobs) 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.(*ListReadSetExportJobsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/exportjobs")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListReadSetExportJobsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListReadSetExportJobsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListReadSetExportJobsInput(v *ListReadSetExportJobsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentListReadSetExportJobsInput(v *ListReadSetExportJobsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentExportReadSetFilter(v.Filter, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListReadSetImportJobs struct {
}
func (*awsRestjson1_serializeOpListReadSetImportJobs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListReadSetImportJobs) 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.(*ListReadSetImportJobsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/importjobs")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListReadSetImportJobsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListReadSetImportJobsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListReadSetImportJobsInput(v *ListReadSetImportJobsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentListReadSetImportJobsInput(v *ListReadSetImportJobsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentImportReadSetFilter(v.Filter, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListReadSets struct {
}
func (*awsRestjson1_serializeOpListReadSets) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListReadSets) 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.(*ListReadSetsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/readsets")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListReadSetsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListReadSetsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListReadSetsInput(v *ListReadSetsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentListReadSetsInput(v *ListReadSetsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentReadSetFilter(v.Filter, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListReadSetUploadParts struct {
}
func (*awsRestjson1_serializeOpListReadSetUploadParts) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListReadSetUploadParts) 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.(*ListReadSetUploadPartsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/upload/{uploadId}/parts")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListReadSetUploadPartsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListReadSetUploadPartsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListReadSetUploadPartsInput(v *ListReadSetUploadPartsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
if v.UploadId == nil || len(*v.UploadId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member uploadId must not be empty")}
}
if v.UploadId != nil {
if err := encoder.SetURI("uploadId").String(*v.UploadId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentListReadSetUploadPartsInput(v *ListReadSetUploadPartsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentReadSetUploadPartListFilter(v.Filter, ok); err != nil {
return err
}
}
if len(v.PartSource) > 0 {
ok := object.Key("partSource")
ok.String(string(v.PartSource))
}
return nil
}
type awsRestjson1_serializeOpListReferenceImportJobs struct {
}
func (*awsRestjson1_serializeOpListReferenceImportJobs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListReferenceImportJobs) 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.(*ListReferenceImportJobsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{referenceStoreId}/importjobs")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListReferenceImportJobsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListReferenceImportJobsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListReferenceImportJobsInput(v *ListReferenceImportJobsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.ReferenceStoreId == nil || len(*v.ReferenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member referenceStoreId must not be empty")}
}
if v.ReferenceStoreId != nil {
if err := encoder.SetURI("referenceStoreId").String(*v.ReferenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentListReferenceImportJobsInput(v *ListReferenceImportJobsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentImportReferenceFilter(v.Filter, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListReferences struct {
}
func (*awsRestjson1_serializeOpListReferences) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListReferences) 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.(*ListReferencesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{referenceStoreId}/references")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListReferencesInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListReferencesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListReferencesInput(v *ListReferencesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.ReferenceStoreId == nil || len(*v.ReferenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member referenceStoreId must not be empty")}
}
if v.ReferenceStoreId != nil {
if err := encoder.SetURI("referenceStoreId").String(*v.ReferenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentListReferencesInput(v *ListReferencesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentReferenceFilter(v.Filter, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListReferenceStores struct {
}
func (*awsRestjson1_serializeOpListReferenceStores) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListReferenceStores) 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.(*ListReferenceStoresInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestores")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListReferenceStoresInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListReferenceStoresInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListReferenceStoresInput(v *ListReferenceStoresInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
func awsRestjson1_serializeOpDocumentListReferenceStoresInput(v *ListReferenceStoresInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentReferenceStoreFilter(v.Filter, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListRunGroups struct {
}
func (*awsRestjson1_serializeOpListRunGroups) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListRunGroups) 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.(*ListRunGroupsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/runGroup")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListRunGroupsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListRunGroupsInput(v *ListRunGroupsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.Name != nil {
encoder.SetQuery("name").String(*v.Name)
}
if v.StartingToken != nil {
encoder.SetQuery("startingToken").String(*v.StartingToken)
}
return nil
}
type awsRestjson1_serializeOpListRuns struct {
}
func (*awsRestjson1_serializeOpListRuns) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListRuns) 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.(*ListRunsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/run")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListRunsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListRunsInput(v *ListRunsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.Name != nil {
encoder.SetQuery("name").String(*v.Name)
}
if v.RunGroupId != nil {
encoder.SetQuery("runGroupId").String(*v.RunGroupId)
}
if v.StartingToken != nil {
encoder.SetQuery("startingToken").String(*v.StartingToken)
}
if len(v.Status) > 0 {
encoder.SetQuery("status").String(string(v.Status))
}
return nil
}
type awsRestjson1_serializeOpListRunTasks struct {
}
func (*awsRestjson1_serializeOpListRunTasks) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListRunTasks) 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.(*ListRunTasksInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/run/{id}/task")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListRunTasksInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListRunTasksInput(v *ListRunTasksInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.StartingToken != nil {
encoder.SetQuery("startingToken").String(*v.StartingToken)
}
if len(v.Status) > 0 {
encoder.SetQuery("status").String(string(v.Status))
}
return nil
}
type awsRestjson1_serializeOpListSequenceStores struct {
}
func (*awsRestjson1_serializeOpListSequenceStores) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListSequenceStores) 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.(*ListSequenceStoresInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestores")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListSequenceStoresInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListSequenceStoresInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListSequenceStoresInput(v *ListSequenceStoresInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
func awsRestjson1_serializeOpDocumentListSequenceStoresInput(v *ListSequenceStoresInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentSequenceStoreFilter(v.Filter, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListTagsForResource struct {
}
func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListTagsForResource) 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.(*ListTagsForResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListVariantImportJobs struct {
}
func (*awsRestjson1_serializeOpListVariantImportJobs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListVariantImportJobs) 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.(*ListVariantImportJobsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/import/variants")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListVariantImportJobsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListVariantImportJobsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListVariantImportJobsInput(v *ListVariantImportJobsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
func awsRestjson1_serializeOpDocumentListVariantImportJobsInput(v *ListVariantImportJobsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentListVariantImportJobsFilter(v.Filter, ok); err != nil {
return err
}
}
if v.Ids != nil {
ok := object.Key("ids")
if err := awsRestjson1_serializeDocumentIdList(v.Ids, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListVariantStores struct {
}
func (*awsRestjson1_serializeOpListVariantStores) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListVariantStores) 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.(*ListVariantStoresInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/variantStores")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListVariantStoresInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListVariantStoresInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListVariantStoresInput(v *ListVariantStoresInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
func awsRestjson1_serializeOpDocumentListVariantStoresInput(v *ListVariantStoresInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filter != nil {
ok := object.Key("filter")
if err := awsRestjson1_serializeDocumentListVariantStoresFilter(v.Filter, ok); err != nil {
return err
}
}
if v.Ids != nil {
ok := object.Key("ids")
if err := awsRestjson1_serializeDocumentIdList(v.Ids, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListWorkflows struct {
}
func (*awsRestjson1_serializeOpListWorkflows) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListWorkflows) 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.(*ListWorkflowsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/workflow")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListWorkflowsInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsListWorkflowsInput(v *ListWorkflowsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.Name != nil {
encoder.SetQuery("name").String(*v.Name)
}
if v.StartingToken != nil {
encoder.SetQuery("startingToken").String(*v.StartingToken)
}
if len(v.Type) > 0 {
encoder.SetQuery("type").String(string(v.Type))
}
return nil
}
type awsRestjson1_serializeOpStartAnnotationImportJob struct {
}
func (*awsRestjson1_serializeOpStartAnnotationImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartAnnotationImportJob) 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.(*StartAnnotationImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/import/annotation")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartAnnotationImportJobInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartAnnotationImportJobInput(v *StartAnnotationImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartAnnotationImportJobInput(v *StartAnnotationImportJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AnnotationFields != nil {
ok := object.Key("annotationFields")
if err := awsRestjson1_serializeDocumentAnnotationFieldMap(v.AnnotationFields, ok); err != nil {
return err
}
}
if v.DestinationName != nil {
ok := object.Key("destinationName")
ok.String(*v.DestinationName)
}
if v.FormatOptions != nil {
ok := object.Key("formatOptions")
if err := awsRestjson1_serializeDocumentFormatOptions(v.FormatOptions, ok); err != nil {
return err
}
}
if v.Items != nil {
ok := object.Key("items")
if err := awsRestjson1_serializeDocumentAnnotationImportItemSources(v.Items, ok); err != nil {
return err
}
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.RunLeftNormalization {
ok := object.Key("runLeftNormalization")
ok.Boolean(v.RunLeftNormalization)
}
return nil
}
type awsRestjson1_serializeOpStartReadSetActivationJob struct {
}
func (*awsRestjson1_serializeOpStartReadSetActivationJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartReadSetActivationJob) 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.(*StartReadSetActivationJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/activationjob")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsStartReadSetActivationJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartReadSetActivationJobInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartReadSetActivationJobInput(v *StartReadSetActivationJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartReadSetActivationJobInput(v *StartReadSetActivationJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.Sources != nil {
ok := object.Key("sources")
if err := awsRestjson1_serializeDocumentStartReadSetActivationJobSourceList(v.Sources, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartReadSetExportJob struct {
}
func (*awsRestjson1_serializeOpStartReadSetExportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartReadSetExportJob) 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.(*StartReadSetExportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/exportjob")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsStartReadSetExportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartReadSetExportJobInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartReadSetExportJobInput(v *StartReadSetExportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartReadSetExportJobInput(v *StartReadSetExportJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.Destination != nil {
ok := object.Key("destination")
ok.String(*v.Destination)
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.Sources != nil {
ok := object.Key("sources")
if err := awsRestjson1_serializeDocumentExportReadSetList(v.Sources, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartReadSetImportJob struct {
}
func (*awsRestjson1_serializeOpStartReadSetImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartReadSetImportJob) 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.(*StartReadSetImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/importjob")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsStartReadSetImportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartReadSetImportJobInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartReadSetImportJobInput(v *StartReadSetImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartReadSetImportJobInput(v *StartReadSetImportJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.Sources != nil {
ok := object.Key("sources")
if err := awsRestjson1_serializeDocumentStartReadSetImportJobSourceList(v.Sources, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartReferenceImportJob struct {
}
func (*awsRestjson1_serializeOpStartReferenceImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartReferenceImportJob) 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.(*StartReferenceImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/referencestore/{referenceStoreId}/importjob")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsStartReferenceImportJobInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartReferenceImportJobInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartReferenceImportJobInput(v *StartReferenceImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ReferenceStoreId == nil || len(*v.ReferenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member referenceStoreId must not be empty")}
}
if v.ReferenceStoreId != nil {
if err := encoder.SetURI("referenceStoreId").String(*v.ReferenceStoreId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartReferenceImportJobInput(v *StartReferenceImportJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.Sources != nil {
ok := object.Key("sources")
if err := awsRestjson1_serializeDocumentStartReferenceImportJobSourceList(v.Sources, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartRun struct {
}
func (*awsRestjson1_serializeOpStartRun) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartRun) 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.(*StartRunInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/run")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartRunInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartRunInput(v *StartRunInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartRunInput(v *StartRunInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.LogLevel) > 0 {
ok := object.Key("logLevel")
ok.String(string(v.LogLevel))
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.OutputUri != nil {
ok := object.Key("outputUri")
ok.String(*v.OutputUri)
}
if v.Parameters != nil {
ok := object.Key("parameters")
if err := awsRestjson1_serializeDocumentRunParameters(v.Parameters, ok); err != nil {
return err
}
}
if v.Priority != nil {
ok := object.Key("priority")
ok.Integer(*v.Priority)
}
if v.RequestId != nil {
ok := object.Key("requestId")
ok.String(*v.RequestId)
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.RunGroupId != nil {
ok := object.Key("runGroupId")
ok.String(*v.RunGroupId)
}
if v.RunId != nil {
ok := object.Key("runId")
ok.String(*v.RunId)
}
if v.StorageCapacity != nil {
ok := object.Key("storageCapacity")
ok.Integer(*v.StorageCapacity)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
if v.WorkflowId != nil {
ok := object.Key("workflowId")
ok.String(*v.WorkflowId)
}
if len(v.WorkflowType) > 0 {
ok := object.Key("workflowType")
ok.String(string(v.WorkflowType))
}
return nil
}
type awsRestjson1_serializeOpStartVariantImportJob struct {
}
func (*awsRestjson1_serializeOpStartVariantImportJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartVariantImportJob) 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.(*StartVariantImportJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/import/variant")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartVariantImportJobInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsStartVariantImportJobInput(v *StartVariantImportJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartVariantImportJobInput(v *StartVariantImportJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AnnotationFields != nil {
ok := object.Key("annotationFields")
if err := awsRestjson1_serializeDocumentAnnotationFieldMap(v.AnnotationFields, ok); err != nil {
return err
}
}
if v.DestinationName != nil {
ok := object.Key("destinationName")
ok.String(*v.DestinationName)
}
if v.Items != nil {
ok := object.Key("items")
if err := awsRestjson1_serializeDocumentVariantImportItemSources(v.Items, ok); err != nil {
return err
}
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.RunLeftNormalization {
ok := object.Key("runLeftNormalization")
ok.Boolean(v.RunLeftNormalization)
}
return nil
}
type awsRestjson1_serializeOpTagResource struct {
}
func (*awsRestjson1_serializeOpTagResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpTagResource) 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.(*TagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUntagResource struct {
}
func (*awsRestjson1_serializeOpUntagResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUntagResource) 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.(*UntagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
if v.TagKeys != nil {
for i := range v.TagKeys {
encoder.AddQuery("tagKeys").String(v.TagKeys[i])
}
}
return nil
}
type awsRestjson1_serializeOpUpdateAnnotationStore struct {
}
func (*awsRestjson1_serializeOpUpdateAnnotationStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateAnnotationStore) 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.(*UpdateAnnotationStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/annotationStore/{name}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsUpdateAnnotationStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateAnnotationStoreInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateAnnotationStoreInput(v *UpdateAnnotationStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("name").String(*v.Name); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateAnnotationStoreInput(v *UpdateAnnotationStoreInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
return nil
}
type awsRestjson1_serializeOpUpdateRunGroup struct {
}
func (*awsRestjson1_serializeOpUpdateRunGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateRunGroup) 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.(*UpdateRunGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/runGroup/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsUpdateRunGroupInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateRunGroupInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateRunGroupInput(v *UpdateRunGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateRunGroupInput(v *UpdateRunGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxCpus != nil {
ok := object.Key("maxCpus")
ok.Integer(*v.MaxCpus)
}
if v.MaxDuration != nil {
ok := object.Key("maxDuration")
ok.Integer(*v.MaxDuration)
}
if v.MaxGpus != nil {
ok := object.Key("maxGpus")
ok.Integer(*v.MaxGpus)
}
if v.MaxRuns != nil {
ok := object.Key("maxRuns")
ok.Integer(*v.MaxRuns)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
return nil
}
type awsRestjson1_serializeOpUpdateVariantStore struct {
}
func (*awsRestjson1_serializeOpUpdateVariantStore) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateVariantStore) 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.(*UpdateVariantStoreInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/variantStore/{name}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsUpdateVariantStoreInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateVariantStoreInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateVariantStoreInput(v *UpdateVariantStoreInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("name").String(*v.Name); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateVariantStoreInput(v *UpdateVariantStoreInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
return nil
}
type awsRestjson1_serializeOpUpdateWorkflow struct {
}
func (*awsRestjson1_serializeOpUpdateWorkflow) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateWorkflow) 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.(*UpdateWorkflowInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/workflow/{id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsUpdateWorkflowInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateWorkflowInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUpdateWorkflowInput(v *UpdateWorkflowInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateWorkflowInput(v *UpdateWorkflowInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
return nil
}
type awsRestjson1_serializeOpUploadReadSetPart struct {
}
func (*awsRestjson1_serializeOpUploadReadSetPart) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUploadReadSetPart) 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.(*UploadReadSetPartInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sequencestore/{sequenceStoreId}/upload/{uploadId}/part")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsUploadReadSetPartInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if !restEncoder.HasHeader("Content-Type") {
ctx = smithyhttp.SetIsContentTypeDefaultValue(ctx, true)
restEncoder.SetHeader("Content-Type").String("application/octet-stream")
}
if input.Payload != nil {
payload := input.Payload
if request, err = request.SetStream(payload); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUploadReadSetPartInput(v *UploadReadSetPartInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.PartNumber != nil {
encoder.SetQuery("partNumber").Integer(*v.PartNumber)
}
if len(v.PartSource) > 0 {
encoder.SetQuery("partSource").String(string(v.PartSource))
}
if v.SequenceStoreId == nil || len(*v.SequenceStoreId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member sequenceStoreId must not be empty")}
}
if v.SequenceStoreId != nil {
if err := encoder.SetURI("sequenceStoreId").String(*v.SequenceStoreId); err != nil {
return err
}
}
if v.UploadId == nil || len(*v.UploadId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member uploadId must not be empty")}
}
if v.UploadId != nil {
if err := encoder.SetURI("uploadId").String(*v.UploadId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentActivateReadSetFilter(v *types.ActivateReadSetFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
return nil
}
func awsRestjson1_serializeDocumentAnnotationFieldMap(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentAnnotationImportItemSource(v *types.AnnotationImportItemSource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Source != nil {
ok := object.Key("source")
ok.String(*v.Source)
}
return nil
}
func awsRestjson1_serializeDocumentAnnotationImportItemSources(v []types.AnnotationImportItemSource, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentAnnotationImportItemSource(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCompleteReadSetUploadPartList(v []types.CompleteReadSetUploadPartListItem, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentCompleteReadSetUploadPartListItem(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCompleteReadSetUploadPartListItem(v *types.CompleteReadSetUploadPartListItem, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Checksum != nil {
ok := object.Key("checksum")
ok.String(*v.Checksum)
}
if v.PartNumber != nil {
ok := object.Key("partNumber")
ok.Integer(*v.PartNumber)
}
if len(v.PartSource) > 0 {
ok := object.Key("partSource")
ok.String(string(v.PartSource))
}
return nil
}
func awsRestjson1_serializeDocumentExportReadSet(v *types.ExportReadSet, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ReadSetId != nil {
ok := object.Key("readSetId")
ok.String(*v.ReadSetId)
}
return nil
}
func awsRestjson1_serializeDocumentExportReadSetFilter(v *types.ExportReadSetFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
return nil
}
func awsRestjson1_serializeDocumentExportReadSetList(v []types.ExportReadSet, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentExportReadSet(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentFormatOptions(v types.FormatOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.FormatOptionsMemberTsvOptions:
av := object.Key("tsvOptions")
if err := awsRestjson1_serializeDocumentTsvOptions(&uv.Value, av); err != nil {
return err
}
case *types.FormatOptionsMemberVcfOptions:
av := object.Key("vcfOptions")
if err := awsRestjson1_serializeDocumentVcfOptions(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentFormatToHeader(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentImportReadSetFilter(v *types.ImportReadSetFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
return nil
}
func awsRestjson1_serializeDocumentImportReferenceFilter(v *types.ImportReferenceFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
return nil
}
func awsRestjson1_serializeDocumentListAnnotationImportJobsFilter(v *types.ListAnnotationImportJobsFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
if v.StoreName != nil {
ok := object.Key("storeName")
ok.String(*v.StoreName)
}
return nil
}
func awsRestjson1_serializeDocumentListAnnotationStoresFilter(v *types.ListAnnotationStoresFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
return nil
}
func awsRestjson1_serializeDocumentListVariantImportJobsFilter(v *types.ListVariantImportJobsFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
if v.StoreName != nil {
ok := object.Key("storeName")
ok.String(*v.StoreName)
}
return nil
}
func awsRestjson1_serializeDocumentListVariantStoresFilter(v *types.ListVariantStoresFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
return nil
}
func awsRestjson1_serializeDocumentReadOptions(v *types.ReadOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Comment != nil {
ok := object.Key("comment")
ok.String(*v.Comment)
}
if v.Encoding != nil {
ok := object.Key("encoding")
ok.String(*v.Encoding)
}
if v.Escape != nil {
ok := object.Key("escape")
ok.String(*v.Escape)
}
if v.EscapeQuotes {
ok := object.Key("escapeQuotes")
ok.Boolean(v.EscapeQuotes)
}
if v.Header {
ok := object.Key("header")
ok.Boolean(v.Header)
}
if v.LineSep != nil {
ok := object.Key("lineSep")
ok.String(*v.LineSep)
}
if v.Quote != nil {
ok := object.Key("quote")
ok.String(*v.Quote)
}
if v.QuoteAll {
ok := object.Key("quoteAll")
ok.Boolean(v.QuoteAll)
}
if v.Sep != nil {
ok := object.Key("sep")
ok.String(*v.Sep)
}
return nil
}
func awsRestjson1_serializeDocumentReadSetFilter(v *types.ReadSetFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
if v.GeneratedFrom != nil {
ok := object.Key("generatedFrom")
ok.String(*v.GeneratedFrom)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.ReferenceArn != nil {
ok := object.Key("referenceArn")
ok.String(*v.ReferenceArn)
}
if v.SampleId != nil {
ok := object.Key("sampleId")
ok.String(*v.SampleId)
}
if len(v.Status) > 0 {
ok := object.Key("status")
ok.String(string(v.Status))
}
if v.SubjectId != nil {
ok := object.Key("subjectId")
ok.String(*v.SubjectId)
}
return nil
}
func awsRestjson1_serializeDocumentReadSetIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentReadSetUploadPartListFilter(v *types.ReadSetUploadPartListFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
return nil
}
func awsRestjson1_serializeDocumentReferenceFilter(v *types.ReferenceFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
if v.Md5 != nil {
ok := object.Key("md5")
ok.String(*v.Md5)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
return nil
}
func awsRestjson1_serializeDocumentReferenceItem(v types.ReferenceItem, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.ReferenceItemMemberReferenceArn:
av := object.Key("referenceArn")
av.String(uv.Value)
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentReferenceStoreFilter(v *types.ReferenceStoreFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
return nil
}
func awsRestjson1_serializeDocumentRunParameters(v document.Interface, value smithyjson.Value) error {
if v == nil {
return nil
}
if !internaldocument.IsInterface(v) {
return fmt.Errorf("%T is not a compatible document type", v)
}
db, err := v.MarshalSmithyDocument()
if err != nil {
return err
}
value.Write(db)
return nil
}
func awsRestjson1_serializeDocumentSchema(v []map[string]types.SchemaValueType, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if vv := v[i]; vv == nil {
continue
}
if err := awsRestjson1_serializeDocumentSchemaItem(v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSchemaItem(v map[string]types.SchemaValueType, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(string(v[key]))
}
return nil
}
func awsRestjson1_serializeDocumentSequenceStoreFilter(v *types.SequenceStoreFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreatedAfter != nil {
ok := object.Key("createdAfter")
ok.String(smithytime.FormatDateTime(*v.CreatedAfter))
}
if v.CreatedBefore != nil {
ok := object.Key("createdBefore")
ok.String(smithytime.FormatDateTime(*v.CreatedBefore))
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
return nil
}
func awsRestjson1_serializeDocumentSourceFiles(v *types.SourceFiles, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Source1 != nil {
ok := object.Key("source1")
ok.String(*v.Source1)
}
if v.Source2 != nil {
ok := object.Key("source2")
ok.String(*v.Source2)
}
return nil
}
func awsRestjson1_serializeDocumentSseConfig(v *types.SseConfig, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyArn != nil {
ok := object.Key("keyArn")
ok.String(*v.KeyArn)
}
if len(v.Type) > 0 {
ok := object.Key("type")
ok.String(string(v.Type))
}
return nil
}
func awsRestjson1_serializeDocumentStartReadSetActivationJobSourceItem(v *types.StartReadSetActivationJobSourceItem, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ReadSetId != nil {
ok := object.Key("readSetId")
ok.String(*v.ReadSetId)
}
return nil
}
func awsRestjson1_serializeDocumentStartReadSetActivationJobSourceList(v []types.StartReadSetActivationJobSourceItem, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentStartReadSetActivationJobSourceItem(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentStartReadSetImportJobSourceItem(v *types.StartReadSetImportJobSourceItem, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.GeneratedFrom != nil {
ok := object.Key("generatedFrom")
ok.String(*v.GeneratedFrom)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.ReferenceArn != nil {
ok := object.Key("referenceArn")
ok.String(*v.ReferenceArn)
}
if v.SampleId != nil {
ok := object.Key("sampleId")
ok.String(*v.SampleId)
}
if v.SourceFiles != nil {
ok := object.Key("sourceFiles")
if err := awsRestjson1_serializeDocumentSourceFiles(v.SourceFiles, ok); err != nil {
return err
}
}
if len(v.SourceFileType) > 0 {
ok := object.Key("sourceFileType")
ok.String(string(v.SourceFileType))
}
if v.SubjectId != nil {
ok := object.Key("subjectId")
ok.String(*v.SubjectId)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentStartReadSetImportJobSourceList(v []types.StartReadSetImportJobSourceItem, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentStartReadSetImportJobSourceItem(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentStartReferenceImportJobSourceItem(v *types.StartReferenceImportJobSourceItem, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.SourceFile != nil {
ok := object.Key("sourceFile")
ok.String(*v.SourceFile)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentStartReferenceImportJobSourceList(v []types.StartReferenceImportJobSourceItem, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentStartReferenceImportJobSourceItem(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentStoreOptions(v types.StoreOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.StoreOptionsMemberTsvStoreOptions:
av := object.Key("tsvStoreOptions")
if err := awsRestjson1_serializeDocumentTsvStoreOptions(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentTsvOptions(v *types.TsvOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ReadOptions != nil {
ok := object.Key("readOptions")
if err := awsRestjson1_serializeDocumentReadOptions(v.ReadOptions, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTsvStoreOptions(v *types.TsvStoreOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.AnnotationType) > 0 {
ok := object.Key("annotationType")
ok.String(string(v.AnnotationType))
}
if v.FormatToHeader != nil {
ok := object.Key("formatToHeader")
if err := awsRestjson1_serializeDocumentFormatToHeader(v.FormatToHeader, ok); err != nil {
return err
}
}
if v.Schema != nil {
ok := object.Key("schema")
if err := awsRestjson1_serializeDocumentSchema(v.Schema, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentVariantImportItemSource(v *types.VariantImportItemSource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Source != nil {
ok := object.Key("source")
ok.String(*v.Source)
}
return nil
}
func awsRestjson1_serializeDocumentVariantImportItemSources(v []types.VariantImportItemSource, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentVariantImportItemSource(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentVcfOptions(v *types.VcfOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IgnoreFilterField != nil {
ok := object.Key("ignoreFilterField")
ok.Boolean(*v.IgnoreFilterField)
}
if v.IgnoreQualField != nil {
ok := object.Key("ignoreQualField")
ok.Boolean(*v.IgnoreQualField)
}
return nil
}
func awsRestjson1_serializeDocumentWorkflowParameter(v *types.WorkflowParameter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.Optional != nil {
ok := object.Key("optional")
ok.Boolean(*v.Optional)
}
return nil
}
func awsRestjson1_serializeDocumentWorkflowParameterTemplate(v map[string]types.WorkflowParameter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
mapVar := v[key]
if err := awsRestjson1_serializeDocumentWorkflowParameter(&mapVar, om); err != nil {
return err
}
}
return nil
}
| 6,506 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package omics
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpAbortMultipartReadSetUpload struct {
}
func (*validateOpAbortMultipartReadSetUpload) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAbortMultipartReadSetUpload) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AbortMultipartReadSetUploadInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAbortMultipartReadSetUploadInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchDeleteReadSet struct {
}
func (*validateOpBatchDeleteReadSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchDeleteReadSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchDeleteReadSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchDeleteReadSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelAnnotationImportJob struct {
}
func (*validateOpCancelAnnotationImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelAnnotationImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelAnnotationImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelAnnotationImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelRun struct {
}
func (*validateOpCancelRun) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelRunInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelRunInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelVariantImportJob struct {
}
func (*validateOpCancelVariantImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelVariantImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelVariantImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelVariantImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCompleteMultipartReadSetUpload struct {
}
func (*validateOpCompleteMultipartReadSetUpload) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCompleteMultipartReadSetUpload) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CompleteMultipartReadSetUploadInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCompleteMultipartReadSetUploadInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateAnnotationStore struct {
}
func (*validateOpCreateAnnotationStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateAnnotationStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateAnnotationStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateAnnotationStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateMultipartReadSetUpload struct {
}
func (*validateOpCreateMultipartReadSetUpload) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateMultipartReadSetUpload) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateMultipartReadSetUploadInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateMultipartReadSetUploadInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateReferenceStore struct {
}
func (*validateOpCreateReferenceStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateReferenceStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateReferenceStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateReferenceStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateRunGroup struct {
}
func (*validateOpCreateRunGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateRunGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateRunGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateRunGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSequenceStore struct {
}
func (*validateOpCreateSequenceStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSequenceStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSequenceStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSequenceStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateVariantStore struct {
}
func (*validateOpCreateVariantStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateVariantStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateVariantStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateVariantStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateWorkflow struct {
}
func (*validateOpCreateWorkflow) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateWorkflow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateWorkflowInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateWorkflowInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteAnnotationStore struct {
}
func (*validateOpDeleteAnnotationStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteAnnotationStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteAnnotationStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteAnnotationStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteReference struct {
}
func (*validateOpDeleteReference) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteReference) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteReferenceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteReferenceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteReferenceStore struct {
}
func (*validateOpDeleteReferenceStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteReferenceStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteReferenceStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteReferenceStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteRunGroup struct {
}
func (*validateOpDeleteRunGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteRunGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteRunGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteRunGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteRun struct {
}
func (*validateOpDeleteRun) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteRunInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteRunInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteSequenceStore struct {
}
func (*validateOpDeleteSequenceStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteSequenceStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteSequenceStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteSequenceStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteVariantStore struct {
}
func (*validateOpDeleteVariantStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteVariantStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteVariantStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteVariantStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteWorkflow struct {
}
func (*validateOpDeleteWorkflow) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteWorkflow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteWorkflowInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteWorkflowInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetAnnotationImportJob struct {
}
func (*validateOpGetAnnotationImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetAnnotationImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetAnnotationImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetAnnotationImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetAnnotationStore struct {
}
func (*validateOpGetAnnotationStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetAnnotationStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetAnnotationStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetAnnotationStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReadSetActivationJob struct {
}
func (*validateOpGetReadSetActivationJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReadSetActivationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReadSetActivationJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReadSetActivationJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReadSetExportJob struct {
}
func (*validateOpGetReadSetExportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReadSetExportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReadSetExportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReadSetExportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReadSetImportJob struct {
}
func (*validateOpGetReadSetImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReadSetImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReadSetImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReadSetImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReadSet struct {
}
func (*validateOpGetReadSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReadSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReadSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReadSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReadSetMetadata struct {
}
func (*validateOpGetReadSetMetadata) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReadSetMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReadSetMetadataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReadSetMetadataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReferenceImportJob struct {
}
func (*validateOpGetReferenceImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReferenceImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReferenceImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReferenceImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReference struct {
}
func (*validateOpGetReference) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReference) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReferenceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReferenceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReferenceMetadata struct {
}
func (*validateOpGetReferenceMetadata) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReferenceMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReferenceMetadataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReferenceMetadataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetReferenceStore struct {
}
func (*validateOpGetReferenceStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetReferenceStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetReferenceStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetReferenceStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetRunGroup struct {
}
func (*validateOpGetRunGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetRunGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetRunGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetRunGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetRun struct {
}
func (*validateOpGetRun) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetRunInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetRunInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetRunTask struct {
}
func (*validateOpGetRunTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetRunTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetRunTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetRunTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetSequenceStore struct {
}
func (*validateOpGetSequenceStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetSequenceStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetSequenceStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetSequenceStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetVariantImportJob struct {
}
func (*validateOpGetVariantImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetVariantImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetVariantImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetVariantImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetVariantStore struct {
}
func (*validateOpGetVariantStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetVariantStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetVariantStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetVariantStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWorkflow struct {
}
func (*validateOpGetWorkflow) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWorkflow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWorkflowInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWorkflowInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListMultipartReadSetUploads struct {
}
func (*validateOpListMultipartReadSetUploads) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListMultipartReadSetUploads) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListMultipartReadSetUploadsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListMultipartReadSetUploadsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListReadSetActivationJobs struct {
}
func (*validateOpListReadSetActivationJobs) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListReadSetActivationJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListReadSetActivationJobsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListReadSetActivationJobsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListReadSetExportJobs struct {
}
func (*validateOpListReadSetExportJobs) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListReadSetExportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListReadSetExportJobsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListReadSetExportJobsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListReadSetImportJobs struct {
}
func (*validateOpListReadSetImportJobs) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListReadSetImportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListReadSetImportJobsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListReadSetImportJobsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListReadSets struct {
}
func (*validateOpListReadSets) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListReadSets) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListReadSetsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListReadSetsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListReadSetUploadParts struct {
}
func (*validateOpListReadSetUploadParts) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListReadSetUploadParts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListReadSetUploadPartsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListReadSetUploadPartsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListReferenceImportJobs struct {
}
func (*validateOpListReferenceImportJobs) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListReferenceImportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListReferenceImportJobsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListReferenceImportJobsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListReferences struct {
}
func (*validateOpListReferences) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListReferences) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListReferencesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListReferencesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListRunTasks struct {
}
func (*validateOpListRunTasks) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListRunTasks) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListRunTasksInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListRunTasksInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListTagsForResource struct {
}
func (*validateOpListTagsForResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListTagsForResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListTagsForResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartAnnotationImportJob struct {
}
func (*validateOpStartAnnotationImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartAnnotationImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartAnnotationImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartAnnotationImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartReadSetActivationJob struct {
}
func (*validateOpStartReadSetActivationJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartReadSetActivationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartReadSetActivationJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartReadSetActivationJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartReadSetExportJob struct {
}
func (*validateOpStartReadSetExportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartReadSetExportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartReadSetExportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartReadSetExportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartReadSetImportJob struct {
}
func (*validateOpStartReadSetImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartReadSetImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartReadSetImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartReadSetImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartReferenceImportJob struct {
}
func (*validateOpStartReferenceImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartReferenceImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartReferenceImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartReferenceImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartRun struct {
}
func (*validateOpStartRun) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartRunInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartRunInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartVariantImportJob struct {
}
func (*validateOpStartVariantImportJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartVariantImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartVariantImportJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartVariantImportJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpTagResource struct {
}
func (*validateOpTagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*TagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpTagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUntagResource struct {
}
func (*validateOpUntagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UntagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUntagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateAnnotationStore struct {
}
func (*validateOpUpdateAnnotationStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateAnnotationStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateAnnotationStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateAnnotationStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateRunGroup struct {
}
func (*validateOpUpdateRunGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateRunGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateRunGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateRunGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateVariantStore struct {
}
func (*validateOpUpdateVariantStore) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateVariantStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateVariantStoreInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateVariantStoreInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateWorkflow struct {
}
func (*validateOpUpdateWorkflow) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateWorkflow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateWorkflowInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateWorkflowInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUploadReadSetPart struct {
}
func (*validateOpUploadReadSetPart) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUploadReadSetPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UploadReadSetPartInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUploadReadSetPartInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpAbortMultipartReadSetUploadValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAbortMultipartReadSetUpload{}, middleware.After)
}
func addOpBatchDeleteReadSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchDeleteReadSet{}, middleware.After)
}
func addOpCancelAnnotationImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelAnnotationImportJob{}, middleware.After)
}
func addOpCancelRunValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelRun{}, middleware.After)
}
func addOpCancelVariantImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelVariantImportJob{}, middleware.After)
}
func addOpCompleteMultipartReadSetUploadValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCompleteMultipartReadSetUpload{}, middleware.After)
}
func addOpCreateAnnotationStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateAnnotationStore{}, middleware.After)
}
func addOpCreateMultipartReadSetUploadValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateMultipartReadSetUpload{}, middleware.After)
}
func addOpCreateReferenceStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateReferenceStore{}, middleware.After)
}
func addOpCreateRunGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateRunGroup{}, middleware.After)
}
func addOpCreateSequenceStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSequenceStore{}, middleware.After)
}
func addOpCreateVariantStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateVariantStore{}, middleware.After)
}
func addOpCreateWorkflowValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateWorkflow{}, middleware.After)
}
func addOpDeleteAnnotationStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteAnnotationStore{}, middleware.After)
}
func addOpDeleteReferenceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteReference{}, middleware.After)
}
func addOpDeleteReferenceStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteReferenceStore{}, middleware.After)
}
func addOpDeleteRunGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteRunGroup{}, middleware.After)
}
func addOpDeleteRunValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteRun{}, middleware.After)
}
func addOpDeleteSequenceStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteSequenceStore{}, middleware.After)
}
func addOpDeleteVariantStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteVariantStore{}, middleware.After)
}
func addOpDeleteWorkflowValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteWorkflow{}, middleware.After)
}
func addOpGetAnnotationImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetAnnotationImportJob{}, middleware.After)
}
func addOpGetAnnotationStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetAnnotationStore{}, middleware.After)
}
func addOpGetReadSetActivationJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReadSetActivationJob{}, middleware.After)
}
func addOpGetReadSetExportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReadSetExportJob{}, middleware.After)
}
func addOpGetReadSetImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReadSetImportJob{}, middleware.After)
}
func addOpGetReadSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReadSet{}, middleware.After)
}
func addOpGetReadSetMetadataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReadSetMetadata{}, middleware.After)
}
func addOpGetReferenceImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReferenceImportJob{}, middleware.After)
}
func addOpGetReferenceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReference{}, middleware.After)
}
func addOpGetReferenceMetadataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReferenceMetadata{}, middleware.After)
}
func addOpGetReferenceStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetReferenceStore{}, middleware.After)
}
func addOpGetRunGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetRunGroup{}, middleware.After)
}
func addOpGetRunValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetRun{}, middleware.After)
}
func addOpGetRunTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetRunTask{}, middleware.After)
}
func addOpGetSequenceStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetSequenceStore{}, middleware.After)
}
func addOpGetVariantImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetVariantImportJob{}, middleware.After)
}
func addOpGetVariantStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetVariantStore{}, middleware.After)
}
func addOpGetWorkflowValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWorkflow{}, middleware.After)
}
func addOpListMultipartReadSetUploadsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListMultipartReadSetUploads{}, middleware.After)
}
func addOpListReadSetActivationJobsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListReadSetActivationJobs{}, middleware.After)
}
func addOpListReadSetExportJobsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListReadSetExportJobs{}, middleware.After)
}
func addOpListReadSetImportJobsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListReadSetImportJobs{}, middleware.After)
}
func addOpListReadSetsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListReadSets{}, middleware.After)
}
func addOpListReadSetUploadPartsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListReadSetUploadParts{}, middleware.After)
}
func addOpListReferenceImportJobsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListReferenceImportJobs{}, middleware.After)
}
func addOpListReferencesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListReferences{}, middleware.After)
}
func addOpListRunTasksValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListRunTasks{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpStartAnnotationImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartAnnotationImportJob{}, middleware.After)
}
func addOpStartReadSetActivationJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartReadSetActivationJob{}, middleware.After)
}
func addOpStartReadSetExportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartReadSetExportJob{}, middleware.After)
}
func addOpStartReadSetImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartReadSetImportJob{}, middleware.After)
}
func addOpStartReferenceImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartReferenceImportJob{}, middleware.After)
}
func addOpStartRunValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartRun{}, middleware.After)
}
func addOpStartVariantImportJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartVariantImportJob{}, middleware.After)
}
func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}
func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}
func addOpUpdateAnnotationStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateAnnotationStore{}, middleware.After)
}
func addOpUpdateRunGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateRunGroup{}, middleware.After)
}
func addOpUpdateVariantStoreValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateVariantStore{}, middleware.After)
}
func addOpUpdateWorkflowValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateWorkflow{}, middleware.After)
}
func addOpUploadReadSetPartValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUploadReadSetPart{}, middleware.After)
}
func validateAnnotationImportItemSource(v *types.AnnotationImportItemSource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AnnotationImportItemSource"}
if v.Source == nil {
invalidParams.Add(smithy.NewErrParamRequired("Source"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAnnotationImportItemSources(v []types.AnnotationImportItemSource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AnnotationImportItemSources"}
for i := range v {
if err := validateAnnotationImportItemSource(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCompleteReadSetUploadPartList(v []types.CompleteReadSetUploadPartListItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CompleteReadSetUploadPartList"}
for i := range v {
if err := validateCompleteReadSetUploadPartListItem(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCompleteReadSetUploadPartListItem(v *types.CompleteReadSetUploadPartListItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CompleteReadSetUploadPartListItem"}
if v.PartNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PartNumber"))
}
if len(v.PartSource) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PartSource"))
}
if v.Checksum == nil {
invalidParams.Add(smithy.NewErrParamRequired("Checksum"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateExportReadSet(v *types.ExportReadSet) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportReadSet"}
if v.ReadSetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReadSetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateExportReadSetList(v []types.ExportReadSet) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportReadSetList"}
for i := range v {
if err := validateExportReadSet(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSourceFiles(v *types.SourceFiles) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SourceFiles"}
if v.Source1 == nil {
invalidParams.Add(smithy.NewErrParamRequired("Source1"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSseConfig(v *types.SseConfig) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SseConfig"}
if len(v.Type) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Type"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStartReadSetActivationJobSourceItem(v *types.StartReadSetActivationJobSourceItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReadSetActivationJobSourceItem"}
if v.ReadSetId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReadSetId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStartReadSetActivationJobSourceList(v []types.StartReadSetActivationJobSourceItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReadSetActivationJobSourceList"}
for i := range v {
if err := validateStartReadSetActivationJobSourceItem(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStartReadSetImportJobSourceItem(v *types.StartReadSetImportJobSourceItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReadSetImportJobSourceItem"}
if v.SourceFiles == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceFiles"))
} else if v.SourceFiles != nil {
if err := validateSourceFiles(v.SourceFiles); err != nil {
invalidParams.AddNested("SourceFiles", err.(smithy.InvalidParamsError))
}
}
if len(v.SourceFileType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("SourceFileType"))
}
if v.SubjectId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SubjectId"))
}
if v.SampleId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SampleId"))
}
if v.ReferenceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStartReadSetImportJobSourceList(v []types.StartReadSetImportJobSourceItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReadSetImportJobSourceList"}
for i := range v {
if err := validateStartReadSetImportJobSourceItem(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStartReferenceImportJobSourceItem(v *types.StartReferenceImportJobSourceItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReferenceImportJobSourceItem"}
if v.SourceFile == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceFile"))
}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStartReferenceImportJobSourceList(v []types.StartReferenceImportJobSourceItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReferenceImportJobSourceList"}
for i := range v {
if err := validateStartReferenceImportJobSourceItem(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVariantImportItemSource(v *types.VariantImportItemSource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VariantImportItemSource"}
if v.Source == nil {
invalidParams.Add(smithy.NewErrParamRequired("Source"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVariantImportItemSources(v []types.VariantImportItemSource) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VariantImportItemSources"}
for i := range v {
if err := validateVariantImportItemSource(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAbortMultipartReadSetUploadInput(v *AbortMultipartReadSetUploadInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AbortMultipartReadSetUploadInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.UploadId == nil {
invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchDeleteReadSetInput(v *BatchDeleteReadSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteReadSetInput"}
if v.Ids == nil {
invalidParams.Add(smithy.NewErrParamRequired("Ids"))
}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelAnnotationImportJobInput(v *CancelAnnotationImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelAnnotationImportJobInput"}
if v.JobId == nil {
invalidParams.Add(smithy.NewErrParamRequired("JobId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelRunInput(v *CancelRunInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelRunInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelVariantImportJobInput(v *CancelVariantImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelVariantImportJobInput"}
if v.JobId == nil {
invalidParams.Add(smithy.NewErrParamRequired("JobId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCompleteMultipartReadSetUploadInput(v *CompleteMultipartReadSetUploadInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CompleteMultipartReadSetUploadInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.UploadId == nil {
invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
}
if v.Parts == nil {
invalidParams.Add(smithy.NewErrParamRequired("Parts"))
} else if v.Parts != nil {
if err := validateCompleteReadSetUploadPartList(v.Parts); err != nil {
invalidParams.AddNested("Parts", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateAnnotationStoreInput(v *CreateAnnotationStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateAnnotationStoreInput"}
if v.SseConfig != nil {
if err := validateSseConfig(v.SseConfig); err != nil {
invalidParams.AddNested("SseConfig", err.(smithy.InvalidParamsError))
}
}
if len(v.StoreFormat) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("StoreFormat"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateMultipartReadSetUploadInput(v *CreateMultipartReadSetUploadInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateMultipartReadSetUploadInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if len(v.SourceFileType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("SourceFileType"))
}
if v.SubjectId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SubjectId"))
}
if v.SampleId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SampleId"))
}
if v.ReferenceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceArn"))
}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateReferenceStoreInput(v *CreateReferenceStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateReferenceStoreInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.SseConfig != nil {
if err := validateSseConfig(v.SseConfig); err != nil {
invalidParams.AddNested("SseConfig", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateRunGroupInput(v *CreateRunGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateRunGroupInput"}
if v.RequestId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSequenceStoreInput(v *CreateSequenceStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSequenceStoreInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.SseConfig != nil {
if err := validateSseConfig(v.SseConfig); err != nil {
invalidParams.AddNested("SseConfig", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateVariantStoreInput(v *CreateVariantStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateVariantStoreInput"}
if v.Reference == nil {
invalidParams.Add(smithy.NewErrParamRequired("Reference"))
}
if v.SseConfig != nil {
if err := validateSseConfig(v.SseConfig); err != nil {
invalidParams.AddNested("SseConfig", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateWorkflowInput(v *CreateWorkflowInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateWorkflowInput"}
if v.RequestId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteAnnotationStoreInput(v *DeleteAnnotationStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteAnnotationStoreInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteReferenceInput(v *DeleteReferenceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteReferenceInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.ReferenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteReferenceStoreInput(v *DeleteReferenceStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteReferenceStoreInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteRunGroupInput(v *DeleteRunGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteRunGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteRunInput(v *DeleteRunInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteRunInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteSequenceStoreInput(v *DeleteSequenceStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteSequenceStoreInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteVariantStoreInput(v *DeleteVariantStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteVariantStoreInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteWorkflowInput(v *DeleteWorkflowInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteWorkflowInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetAnnotationImportJobInput(v *GetAnnotationImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetAnnotationImportJobInput"}
if v.JobId == nil {
invalidParams.Add(smithy.NewErrParamRequired("JobId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetAnnotationStoreInput(v *GetAnnotationStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetAnnotationStoreInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReadSetActivationJobInput(v *GetReadSetActivationJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReadSetActivationJobInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReadSetExportJobInput(v *GetReadSetExportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReadSetExportJobInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReadSetImportJobInput(v *GetReadSetImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReadSetImportJobInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReadSetInput(v *GetReadSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReadSetInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.PartNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PartNumber"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReadSetMetadataInput(v *GetReadSetMetadataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReadSetMetadataInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReferenceImportJobInput(v *GetReferenceImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReferenceImportJobInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.ReferenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReferenceInput(v *GetReferenceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReferenceInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.ReferenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceStoreId"))
}
if v.PartNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PartNumber"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReferenceMetadataInput(v *GetReferenceMetadataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReferenceMetadataInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.ReferenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetReferenceStoreInput(v *GetReferenceStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetReferenceStoreInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetRunGroupInput(v *GetRunGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetRunGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetRunInput(v *GetRunInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetRunInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetRunTaskInput(v *GetRunTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetRunTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.TaskId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TaskId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetSequenceStoreInput(v *GetSequenceStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetSequenceStoreInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetVariantImportJobInput(v *GetVariantImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetVariantImportJobInput"}
if v.JobId == nil {
invalidParams.Add(smithy.NewErrParamRequired("JobId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetVariantStoreInput(v *GetVariantStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetVariantStoreInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWorkflowInput(v *GetWorkflowInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWorkflowInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListMultipartReadSetUploadsInput(v *ListMultipartReadSetUploadsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListMultipartReadSetUploadsInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListReadSetActivationJobsInput(v *ListReadSetActivationJobsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListReadSetActivationJobsInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListReadSetExportJobsInput(v *ListReadSetExportJobsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListReadSetExportJobsInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListReadSetImportJobsInput(v *ListReadSetImportJobsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListReadSetImportJobsInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListReadSetsInput(v *ListReadSetsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListReadSetsInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListReadSetUploadPartsInput(v *ListReadSetUploadPartsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListReadSetUploadPartsInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.UploadId == nil {
invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
}
if len(v.PartSource) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PartSource"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListReferenceImportJobsInput(v *ListReferenceImportJobsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListReferenceImportJobsInput"}
if v.ReferenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListReferencesInput(v *ListReferencesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListReferencesInput"}
if v.ReferenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListRunTasksInput(v *ListRunTasksInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListRunTasksInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartAnnotationImportJobInput(v *StartAnnotationImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartAnnotationImportJobInput"}
if v.DestinationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DestinationName"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.Items == nil {
invalidParams.Add(smithy.NewErrParamRequired("Items"))
} else if v.Items != nil {
if err := validateAnnotationImportItemSources(v.Items); err != nil {
invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartReadSetActivationJobInput(v *StartReadSetActivationJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReadSetActivationJobInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.Sources == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sources"))
} else if v.Sources != nil {
if err := validateStartReadSetActivationJobSourceList(v.Sources); err != nil {
invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartReadSetExportJobInput(v *StartReadSetExportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReadSetExportJobInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.Destination == nil {
invalidParams.Add(smithy.NewErrParamRequired("Destination"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.Sources == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sources"))
} else if v.Sources != nil {
if err := validateExportReadSetList(v.Sources); err != nil {
invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartReadSetImportJobInput(v *StartReadSetImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReadSetImportJobInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.Sources == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sources"))
} else if v.Sources != nil {
if err := validateStartReadSetImportJobSourceList(v.Sources); err != nil {
invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartReferenceImportJobInput(v *StartReferenceImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartReferenceImportJobInput"}
if v.ReferenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReferenceStoreId"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.Sources == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sources"))
} else if v.Sources != nil {
if err := validateStartReferenceImportJobSourceList(v.Sources); err != nil {
invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartRunInput(v *StartRunInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartRunInput"}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.RequestId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartVariantImportJobInput(v *StartVariantImportJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartVariantImportJobInput"}
if v.DestinationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DestinationName"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.Items == nil {
invalidParams.Add(smithy.NewErrParamRequired("Items"))
} else if v.Items != nil {
if err := validateVariantImportItemSources(v.Items); err != nil {
invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpTagResourceInput(v *TagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUntagResourceInput(v *UntagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.TagKeys == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateAnnotationStoreInput(v *UpdateAnnotationStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateAnnotationStoreInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateRunGroupInput(v *UpdateRunGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateRunGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateVariantStoreInput(v *UpdateVariantStoreInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateVariantStoreInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateWorkflowInput(v *UpdateWorkflowInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkflowInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUploadReadSetPartInput(v *UploadReadSetPartInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UploadReadSetPartInput"}
if v.SequenceStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SequenceStoreId"))
}
if v.UploadId == nil {
invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
}
if len(v.PartSource) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PartSource"))
}
if v.PartNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PartNumber"))
}
if v.Payload == nil {
invalidParams.Add(smithy.NewErrParamRequired("Payload"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 2,922 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package document implements encoding and decoding of open-content that has a JSON-like data model.
// This data-model allows for UTF-8 strings, arbitrary precision numbers, booleans, nulls, a list of these values, and a
// map of UTF-8 strings to these values.
//
// Interface defines the semantics for how a document type is marshalled and unmarshalled for requests and responses
// for the service. To send a document as input to the service you use NewLazyDocument and pass it the Go type to be
// sent to the service. NewLazyDocument returns a document Interface type that encodes the provided Go type during
// the request serialization step after you have invoked an API client operation that uses the document type.
//
// The following examples show how you can create document types using basic Go types.
//
// NewLazyDocument(map[string]interface{}{
// "favoriteNumber": 42,
// "fruits": []string{"apple", "orange"},
// "capitals": map[string]interface{}{
// "Washington": "Olympia",
// "Oregon": "Salem",
// },
// "skyIsBlue": true,
// })
//
// NewLazyDocument(3.14159)
//
// NewLazyDocument([]interface{"One", 2, 3, 3.5, "four"})
//
// NewLazyDocument(true)
//
// Services can send document types as part of their API responses. To retrieve the content of a response document
// you use the UnmarshalSmithyDocument method on the response document. When calling UnmarshalSmithyDocument you pass
// a reference to the Go type that you want to unmarshal and map the response to.
//
// For example, if you expect to receive key/value map from the service response:
//
// var kv map[string]interface{}
// if err := outputDocument.UnmarshalSmithyDocument(&kv); err != nil {
// // handle error
// }
//
// If a service can return one or more data-types in the response, you can use an empty interface and type switch to
// dynamically handle the response type.
//
// var v interface{}
// if err := outputDocument.UnmarshalSmithyDocument(&v); err != nil {
// // handle error
// }
//
// switch vv := v.(type) {
// case map[string]interface{}:
// // handle key/value map
// case []interface{}:
// // handle array of values
// case bool:
// // handle boolean
// case document.Number:
// // handle an arbitrary precision number
// case string:
// // handle string
// default:
// // handle unknown case
// }
//
// The mapping of Go types to document types is covered in more depth in https://pkg.go.dev/github.com/aws/smithy-go/document
// including more in depth examples that cover user-defined structure types.
package document
| 67 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package document
import (
internaldocument "github.com/aws/aws-sdk-go-v2/service/omics/internal/document"
)
// Interface defines a document which is a protocol-agnostic type which supports a
// JSON-like data-model. You can use this type to send UTF-8 strings, arbitrary
// precision numbers, booleans, nulls, a list of these values, and a map of UTF-8
// strings to these values.
//
// You create a document type using the NewLazyDocument function and passing it
// the Go type to marshal. When receiving a document in an API response, you use
// the document's UnmarshalSmithyDocument function to decode the response to your
// desired Go type. Unless documented specifically generated structure types in
// client packages or client types packages are not supported at this time. Such
// types embed a noSmithyDocumentSerde and will cause an error to be returned when
// attempting to send an API request.
//
// For more information see the accompanying package documentation and linked
// references.
type Interface = internaldocument.Interface
// You create document type using the NewLazyDocument function and passing it the
// Go type to be marshaled and sent to the service. The document marshaler supports
// semantics similar to the encoding/json Go standard library.
//
// For more information see the accompanying package documentation and linked
// references.
func NewLazyDocument(v interface{}) Interface {
return internaldocument.NewDocumentMarshaler(v)
}
| 35 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package document
import (
"bytes"
"encoding/json"
smithydocument "github.com/aws/smithy-go/document"
smithydocumentjson "github.com/aws/smithy-go/document/json"
)
// github.com/aws/aws-sdk-go-v2/service/omics/internal/document.smithyDocument is
// an interface which is used to bind a document type to its service client.
type smithyDocument interface {
isSmithyDocument()
}
// github.com/aws/aws-sdk-go-v2/service/omics/internal/document.Interface is a
// JSON-like data model type that is protocol agnostic and is usedto send
// open-content to a service.
type Interface interface {
smithyDocument
smithydocument.Marshaler
smithydocument.Unmarshaler
}
type documentMarshaler struct {
value interface{}
}
func (m *documentMarshaler) UnmarshalSmithyDocument(v interface{}) error {
mBytes, err := m.MarshalSmithyDocument()
if err != nil {
return err
}
jDecoder := json.NewDecoder(bytes.NewReader(mBytes))
jDecoder.UseNumber()
var jv interface{}
if err := jDecoder.Decode(&v); err != nil {
return err
}
return NewDocumentUnmarshaler(v).UnmarshalSmithyDocument(&jv)
}
func (m *documentMarshaler) MarshalSmithyDocument() ([]byte, error) {
return smithydocumentjson.NewEncoder().Encode(m.value)
}
func (m *documentMarshaler) isSmithyDocument() {}
var _ Interface = (*documentMarshaler)(nil)
type documentUnmarshaler struct {
value interface{}
}
func (m *documentUnmarshaler) UnmarshalSmithyDocument(v interface{}) error {
decoder := smithydocumentjson.NewDecoder()
return decoder.DecodeJSONInterface(m.value, v)
}
func (m *documentUnmarshaler) MarshalSmithyDocument() ([]byte, error) {
return json.Marshal(m.value)
}
func (m *documentUnmarshaler) isSmithyDocument() {}
var _ Interface = (*documentUnmarshaler)(nil)
// NewDocumentMarshaler creates a new document marshaler for the given input type
func NewDocumentMarshaler(v interface{}) Interface {
return &documentMarshaler{
value: v,
}
}
// NewDocumentUnmarshaler creates a new document unmarshaler for the given service
// response
func NewDocumentUnmarshaler(v interface{}) Interface {
return &documentUnmarshaler{
value: v,
}
}
// github.com/aws/aws-sdk-go-v2/service/omics/internal/document.IsInterface
// returns whether the given Interface implementation is a valid client
// implementation
func IsInterface(v Interface) (ok bool) {
defer func() {
if err := recover(); err != nil {
ok = false
}
}()
v.isSmithyDocument()
return true
}
| 100 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package document
import (
smithydocument "github.com/aws/smithy-go/document"
)
var _ smithyDocument = (Interface)(nil)
var _ smithydocument.Marshaler = (Interface)(nil)
var _ smithydocument.Unmarshaler = (Interface)(nil)
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver Omics endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "omics.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "omics-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "omics-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "omics.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "ap-southeast-1",
}: endpoints.Endpoint{
Hostname: "omics.ap-southeast-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-southeast-1",
},
},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{
Hostname: "omics.eu-central-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-central-1",
},
},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{
Hostname: "omics.eu-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-west-1",
},
},
endpoints.EndpointKey{
Region: "eu-west-2",
}: endpoints.Endpoint{
Hostname: "omics.eu-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-west-2",
},
},
endpoints.EndpointKey{
Region: "fips-us-east-1",
}: endpoints.Endpoint{
Hostname: "omics-fips.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-west-2",
}: endpoints.Endpoint{
Hostname: "omics-fips.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{
Hostname: "omics.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
},
endpoints.EndpointKey{
Region: "us-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "omics-fips.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{
Hostname: "omics.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
},
endpoints.EndpointKey{
Region: "us-west-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "omics-fips.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "omics.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "omics-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "omics-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "omics.{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: "omics-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "omics.{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: "omics-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "omics.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "omics-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "omics.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "omics-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "omics.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "omics.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "omics-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "omics-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "omics.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 383 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type Accelerators string
// Enum values for Accelerators
const (
AcceleratorsGpu Accelerators = "GPU"
)
// Values returns all known values for Accelerators. 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 (Accelerators) Values() []Accelerators {
return []Accelerators{
"GPU",
}
}
type AnnotationType string
// Enum values for AnnotationType
const (
// Generic text file. No genomic information
AnnotationTypeGeneric AnnotationType = "GENERIC"
// Contains contig and 1-base position
AnnotationTypeChrPos AnnotationType = "CHR_POS"
// Contains contig, 1-base position, ref and alt allele information
AnnotationTypeChrPosRefAlt AnnotationType = "CHR_POS_REF_ALT"
// Contains contig, start, and end positions. Coordinates are 1-based
AnnotationTypeChrStartEndOneBase AnnotationType = "CHR_START_END_ONE_BASE"
// Contains contig, start, end, ref and alt allele information. Coordinates are
// 1-based
AnnotationTypeChrStartEndRefAltOneBase AnnotationType = "CHR_START_END_REF_ALT_ONE_BASE"
// Contains contig, start, and end positions. Coordinates are 0-based
AnnotationTypeChrStartEndZeroBase AnnotationType = "CHR_START_END_ZERO_BASE"
// Contains contig, start, end, ref and alt allele information. Coordinates are
// 0-based
AnnotationTypeChrStartEndRefAltZeroBase AnnotationType = "CHR_START_END_REF_ALT_ZERO_BASE"
)
// Values returns all known values for AnnotationType. 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 (AnnotationType) Values() []AnnotationType {
return []AnnotationType{
"GENERIC",
"CHR_POS",
"CHR_POS_REF_ALT",
"CHR_START_END_ONE_BASE",
"CHR_START_END_REF_ALT_ONE_BASE",
"CHR_START_END_ZERO_BASE",
"CHR_START_END_REF_ALT_ZERO_BASE",
}
}
type EncryptionType string
// Enum values for EncryptionType
const (
// KMS
EncryptionTypeKms EncryptionType = "KMS"
)
// Values returns all known values for EncryptionType. 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 (EncryptionType) Values() []EncryptionType {
return []EncryptionType{
"KMS",
}
}
type FileType string
// Enum values for FileType
const (
FileTypeFastq FileType = "FASTQ"
FileTypeBam FileType = "BAM"
FileTypeCram FileType = "CRAM"
)
// Values returns all known values for FileType. 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 (FileType) Values() []FileType {
return []FileType{
"FASTQ",
"BAM",
"CRAM",
}
}
type FormatToHeaderKey string
// Enum values for FormatToHeaderKey
const (
FormatToHeaderKeyChr FormatToHeaderKey = "CHR"
FormatToHeaderKeyStart FormatToHeaderKey = "START"
FormatToHeaderKeyEnd FormatToHeaderKey = "END"
FormatToHeaderKeyRef FormatToHeaderKey = "REF"
FormatToHeaderKeyAlt FormatToHeaderKey = "ALT"
FormatToHeaderKeyPos FormatToHeaderKey = "POS"
)
// Values returns all known values for FormatToHeaderKey. 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 (FormatToHeaderKey) Values() []FormatToHeaderKey {
return []FormatToHeaderKey{
"CHR",
"START",
"END",
"REF",
"ALT",
"POS",
}
}
type JobStatus string
// Enum values for JobStatus
const (
// The Job has been submitted to run
JobStatusSubmitted JobStatus = "SUBMITTED"
// The Job is executing
JobStatusInProgress JobStatus = "IN_PROGRESS"
// The Job was cancelled
JobStatusCancelled JobStatus = "CANCELLED"
// The Job has completed
JobStatusCompleted JobStatus = "COMPLETED"
// The Job failed
JobStatusFailed JobStatus = "FAILED"
// The Job completed with failed runs
JobStatusCompletedWithFailures JobStatus = "COMPLETED_WITH_FAILURES"
)
// Values returns all known values for JobStatus. 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 (JobStatus) Values() []JobStatus {
return []JobStatus{
"SUBMITTED",
"IN_PROGRESS",
"CANCELLED",
"COMPLETED",
"FAILED",
"COMPLETED_WITH_FAILURES",
}
}
type ReadSetActivationJobItemStatus string
// Enum values for ReadSetActivationJobItemStatus
const (
ReadSetActivationJobItemStatusNotStarted ReadSetActivationJobItemStatus = "NOT_STARTED"
ReadSetActivationJobItemStatusInProgress ReadSetActivationJobItemStatus = "IN_PROGRESS"
ReadSetActivationJobItemStatusFinished ReadSetActivationJobItemStatus = "FINISHED"
ReadSetActivationJobItemStatusFailed ReadSetActivationJobItemStatus = "FAILED"
)
// Values returns all known values for ReadSetActivationJobItemStatus. 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 (ReadSetActivationJobItemStatus) Values() []ReadSetActivationJobItemStatus {
return []ReadSetActivationJobItemStatus{
"NOT_STARTED",
"IN_PROGRESS",
"FINISHED",
"FAILED",
}
}
type ReadSetActivationJobStatus string
// Enum values for ReadSetActivationJobStatus
const (
ReadSetActivationJobStatusSubmitted ReadSetActivationJobStatus = "SUBMITTED"
ReadSetActivationJobStatusInProgress ReadSetActivationJobStatus = "IN_PROGRESS"
ReadSetActivationJobStatusCancelling ReadSetActivationJobStatus = "CANCELLING"
ReadSetActivationJobStatusCancelled ReadSetActivationJobStatus = "CANCELLED"
ReadSetActivationJobStatusFailed ReadSetActivationJobStatus = "FAILED"
ReadSetActivationJobStatusCompleted ReadSetActivationJobStatus = "COMPLETED"
ReadSetActivationJobStatusCompletedWithFailures ReadSetActivationJobStatus = "COMPLETED_WITH_FAILURES"
)
// Values returns all known values for ReadSetActivationJobStatus. 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 (ReadSetActivationJobStatus) Values() []ReadSetActivationJobStatus {
return []ReadSetActivationJobStatus{
"SUBMITTED",
"IN_PROGRESS",
"CANCELLING",
"CANCELLED",
"FAILED",
"COMPLETED",
"COMPLETED_WITH_FAILURES",
}
}
type ReadSetExportJobItemStatus string
// Enum values for ReadSetExportJobItemStatus
const (
ReadSetExportJobItemStatusNotStarted ReadSetExportJobItemStatus = "NOT_STARTED"
ReadSetExportJobItemStatusInProgress ReadSetExportJobItemStatus = "IN_PROGRESS"
ReadSetExportJobItemStatusFinished ReadSetExportJobItemStatus = "FINISHED"
ReadSetExportJobItemStatusFailed ReadSetExportJobItemStatus = "FAILED"
)
// Values returns all known values for ReadSetExportJobItemStatus. 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 (ReadSetExportJobItemStatus) Values() []ReadSetExportJobItemStatus {
return []ReadSetExportJobItemStatus{
"NOT_STARTED",
"IN_PROGRESS",
"FINISHED",
"FAILED",
}
}
type ReadSetExportJobStatus string
// Enum values for ReadSetExportJobStatus
const (
ReadSetExportJobStatusSubmitted ReadSetExportJobStatus = "SUBMITTED"
ReadSetExportJobStatusInProgress ReadSetExportJobStatus = "IN_PROGRESS"
ReadSetExportJobStatusCancelling ReadSetExportJobStatus = "CANCELLING"
ReadSetExportJobStatusCancelled ReadSetExportJobStatus = "CANCELLED"
ReadSetExportJobStatusFailed ReadSetExportJobStatus = "FAILED"
ReadSetExportJobStatusCompleted ReadSetExportJobStatus = "COMPLETED"
ReadSetExportJobStatusCompletedWithFailures ReadSetExportJobStatus = "COMPLETED_WITH_FAILURES"
)
// Values returns all known values for ReadSetExportJobStatus. 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 (ReadSetExportJobStatus) Values() []ReadSetExportJobStatus {
return []ReadSetExportJobStatus{
"SUBMITTED",
"IN_PROGRESS",
"CANCELLING",
"CANCELLED",
"FAILED",
"COMPLETED",
"COMPLETED_WITH_FAILURES",
}
}
type ReadSetFile string
// Enum values for ReadSetFile
const (
ReadSetFileSource1 ReadSetFile = "SOURCE1"
ReadSetFileSource2 ReadSetFile = "SOURCE2"
ReadSetFileIndex ReadSetFile = "INDEX"
)
// Values returns all known values for ReadSetFile. 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 (ReadSetFile) Values() []ReadSetFile {
return []ReadSetFile{
"SOURCE1",
"SOURCE2",
"INDEX",
}
}
type ReadSetImportJobItemStatus string
// Enum values for ReadSetImportJobItemStatus
const (
ReadSetImportJobItemStatusNotStarted ReadSetImportJobItemStatus = "NOT_STARTED"
ReadSetImportJobItemStatusInProgress ReadSetImportJobItemStatus = "IN_PROGRESS"
ReadSetImportJobItemStatusFinished ReadSetImportJobItemStatus = "FINISHED"
ReadSetImportJobItemStatusFailed ReadSetImportJobItemStatus = "FAILED"
)
// Values returns all known values for ReadSetImportJobItemStatus. 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 (ReadSetImportJobItemStatus) Values() []ReadSetImportJobItemStatus {
return []ReadSetImportJobItemStatus{
"NOT_STARTED",
"IN_PROGRESS",
"FINISHED",
"FAILED",
}
}
type ReadSetImportJobStatus string
// Enum values for ReadSetImportJobStatus
const (
ReadSetImportJobStatusSubmitted ReadSetImportJobStatus = "SUBMITTED"
ReadSetImportJobStatusInProgress ReadSetImportJobStatus = "IN_PROGRESS"
ReadSetImportJobStatusCancelling ReadSetImportJobStatus = "CANCELLING"
ReadSetImportJobStatusCancelled ReadSetImportJobStatus = "CANCELLED"
ReadSetImportJobStatusFailed ReadSetImportJobStatus = "FAILED"
ReadSetImportJobStatusCompleted ReadSetImportJobStatus = "COMPLETED"
ReadSetImportJobStatusCompletedWithFailures ReadSetImportJobStatus = "COMPLETED_WITH_FAILURES"
)
// Values returns all known values for ReadSetImportJobStatus. 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 (ReadSetImportJobStatus) Values() []ReadSetImportJobStatus {
return []ReadSetImportJobStatus{
"SUBMITTED",
"IN_PROGRESS",
"CANCELLING",
"CANCELLED",
"FAILED",
"COMPLETED",
"COMPLETED_WITH_FAILURES",
}
}
type ReadSetPartSource string
// Enum values for ReadSetPartSource
const (
ReadSetPartSourceSource1 ReadSetPartSource = "SOURCE1"
ReadSetPartSourceSource2 ReadSetPartSource = "SOURCE2"
)
// Values returns all known values for ReadSetPartSource. 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 (ReadSetPartSource) Values() []ReadSetPartSource {
return []ReadSetPartSource{
"SOURCE1",
"SOURCE2",
}
}
type ReadSetStatus string
// Enum values for ReadSetStatus
const (
ReadSetStatusArchived ReadSetStatus = "ARCHIVED"
ReadSetStatusActivating ReadSetStatus = "ACTIVATING"
ReadSetStatusActive ReadSetStatus = "ACTIVE"
ReadSetStatusDeleting ReadSetStatus = "DELETING"
ReadSetStatusDeleted ReadSetStatus = "DELETED"
ReadSetStatusProcessingUpload ReadSetStatus = "PROCESSING_UPLOAD"
ReadSetStatusUploadFailed ReadSetStatus = "UPLOAD_FAILED"
)
// Values returns all known values for ReadSetStatus. 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 (ReadSetStatus) Values() []ReadSetStatus {
return []ReadSetStatus{
"ARCHIVED",
"ACTIVATING",
"ACTIVE",
"DELETING",
"DELETED",
"PROCESSING_UPLOAD",
"UPLOAD_FAILED",
}
}
type ReferenceFile string
// Enum values for ReferenceFile
const (
ReferenceFileSource ReferenceFile = "SOURCE"
ReferenceFileIndex ReferenceFile = "INDEX"
)
// Values returns all known values for ReferenceFile. 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 (ReferenceFile) Values() []ReferenceFile {
return []ReferenceFile{
"SOURCE",
"INDEX",
}
}
type ReferenceImportJobItemStatus string
// Enum values for ReferenceImportJobItemStatus
const (
ReferenceImportJobItemStatusNotStarted ReferenceImportJobItemStatus = "NOT_STARTED"
ReferenceImportJobItemStatusInProgress ReferenceImportJobItemStatus = "IN_PROGRESS"
ReferenceImportJobItemStatusFinished ReferenceImportJobItemStatus = "FINISHED"
ReferenceImportJobItemStatusFailed ReferenceImportJobItemStatus = "FAILED"
)
// Values returns all known values for ReferenceImportJobItemStatus. 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 (ReferenceImportJobItemStatus) Values() []ReferenceImportJobItemStatus {
return []ReferenceImportJobItemStatus{
"NOT_STARTED",
"IN_PROGRESS",
"FINISHED",
"FAILED",
}
}
type ReferenceImportJobStatus string
// Enum values for ReferenceImportJobStatus
const (
ReferenceImportJobStatusSubmitted ReferenceImportJobStatus = "SUBMITTED"
ReferenceImportJobStatusInProgress ReferenceImportJobStatus = "IN_PROGRESS"
ReferenceImportJobStatusCancelling ReferenceImportJobStatus = "CANCELLING"
ReferenceImportJobStatusCancelled ReferenceImportJobStatus = "CANCELLED"
ReferenceImportJobStatusFailed ReferenceImportJobStatus = "FAILED"
ReferenceImportJobStatusCompleted ReferenceImportJobStatus = "COMPLETED"
ReferenceImportJobStatusCompletedWithFailures ReferenceImportJobStatus = "COMPLETED_WITH_FAILURES"
)
// Values returns all known values for ReferenceImportJobStatus. 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 (ReferenceImportJobStatus) Values() []ReferenceImportJobStatus {
return []ReferenceImportJobStatus{
"SUBMITTED",
"IN_PROGRESS",
"CANCELLING",
"CANCELLED",
"FAILED",
"COMPLETED",
"COMPLETED_WITH_FAILURES",
}
}
type ReferenceStatus string
// Enum values for ReferenceStatus
const (
ReferenceStatusActive ReferenceStatus = "ACTIVE"
ReferenceStatusDeleting ReferenceStatus = "DELETING"
ReferenceStatusDeleted ReferenceStatus = "DELETED"
)
// Values returns all known values for ReferenceStatus. 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 (ReferenceStatus) Values() []ReferenceStatus {
return []ReferenceStatus{
"ACTIVE",
"DELETING",
"DELETED",
}
}
type RunExport string
// Enum values for RunExport
const (
RunExportDefinition RunExport = "DEFINITION"
)
// Values returns all known values for RunExport. 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 (RunExport) Values() []RunExport {
return []RunExport{
"DEFINITION",
}
}
type RunLogLevel string
// Enum values for RunLogLevel
const (
RunLogLevelOff RunLogLevel = "OFF"
RunLogLevelFatal RunLogLevel = "FATAL"
RunLogLevelError RunLogLevel = "ERROR"
RunLogLevelAll RunLogLevel = "ALL"
)
// Values returns all known values for RunLogLevel. 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 (RunLogLevel) Values() []RunLogLevel {
return []RunLogLevel{
"OFF",
"FATAL",
"ERROR",
"ALL",
}
}
type RunStatus string
// Enum values for RunStatus
const (
RunStatusPending RunStatus = "PENDING"
RunStatusStarting RunStatus = "STARTING"
RunStatusRunning RunStatus = "RUNNING"
RunStatusStopping RunStatus = "STOPPING"
RunStatusCompleted RunStatus = "COMPLETED"
RunStatusDeleted RunStatus = "DELETED"
RunStatusCancelled RunStatus = "CANCELLED"
RunStatusFailed RunStatus = "FAILED"
)
// Values returns all known values for RunStatus. 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 (RunStatus) Values() []RunStatus {
return []RunStatus{
"PENDING",
"STARTING",
"RUNNING",
"STOPPING",
"COMPLETED",
"DELETED",
"CANCELLED",
"FAILED",
}
}
type SchemaValueType string
// Enum values for SchemaValueType
const (
// LONG type
SchemaValueTypeLong SchemaValueType = "LONG"
// INT type
SchemaValueTypeInt SchemaValueType = "INT"
// STRING type
SchemaValueTypeString SchemaValueType = "STRING"
// FLOAT type
SchemaValueTypeFloat SchemaValueType = "FLOAT"
// DOUBLE type
SchemaValueTypeDouble SchemaValueType = "DOUBLE"
// BOOLEAN type
SchemaValueTypeBoolean SchemaValueType = "BOOLEAN"
)
// Values returns all known values for SchemaValueType. 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 (SchemaValueType) Values() []SchemaValueType {
return []SchemaValueType{
"LONG",
"INT",
"STRING",
"FLOAT",
"DOUBLE",
"BOOLEAN",
}
}
type StoreFormat string
// Enum values for StoreFormat
const (
// GFF3 Format
StoreFormatGff StoreFormat = "GFF"
// TSV Format
StoreFormatTsv StoreFormat = "TSV"
// VCF Format
StoreFormatVcf StoreFormat = "VCF"
)
// Values returns all known values for StoreFormat. 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 (StoreFormat) Values() []StoreFormat {
return []StoreFormat{
"GFF",
"TSV",
"VCF",
}
}
type StoreStatus string
// Enum values for StoreStatus
const (
// The Store is being created
StoreStatusCreating StoreStatus = "CREATING"
// The Store is updating
StoreStatusUpdating StoreStatus = "UPDATING"
// The Store is deleting
StoreStatusDeleting StoreStatus = "DELETING"
// The Store is active
StoreStatusActive StoreStatus = "ACTIVE"
// The Store creation failed
StoreStatusFailed StoreStatus = "FAILED"
)
// Values returns all known values for StoreStatus. 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 (StoreStatus) Values() []StoreStatus {
return []StoreStatus{
"CREATING",
"UPDATING",
"DELETING",
"ACTIVE",
"FAILED",
}
}
type TaskStatus string
// Enum values for TaskStatus
const (
TaskStatusPending TaskStatus = "PENDING"
TaskStatusStarting TaskStatus = "STARTING"
TaskStatusRunning TaskStatus = "RUNNING"
TaskStatusStopping TaskStatus = "STOPPING"
TaskStatusCompleted TaskStatus = "COMPLETED"
TaskStatusCancelled TaskStatus = "CANCELLED"
TaskStatusFailed TaskStatus = "FAILED"
)
// Values returns all known values for TaskStatus. 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 (TaskStatus) Values() []TaskStatus {
return []TaskStatus{
"PENDING",
"STARTING",
"RUNNING",
"STOPPING",
"COMPLETED",
"CANCELLED",
"FAILED",
}
}
type WorkflowEngine string
// Enum values for WorkflowEngine
const (
WorkflowEngineWdl WorkflowEngine = "WDL"
WorkflowEngineNextflow WorkflowEngine = "NEXTFLOW"
WorkflowEngineCwl WorkflowEngine = "CWL"
)
// Values returns all known values for WorkflowEngine. 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 (WorkflowEngine) Values() []WorkflowEngine {
return []WorkflowEngine{
"WDL",
"NEXTFLOW",
"CWL",
}
}
type WorkflowExport string
// Enum values for WorkflowExport
const (
WorkflowExportDefinition WorkflowExport = "DEFINITION"
)
// Values returns all known values for WorkflowExport. 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 (WorkflowExport) Values() []WorkflowExport {
return []WorkflowExport{
"DEFINITION",
}
}
type WorkflowStatus string
// Enum values for WorkflowStatus
const (
WorkflowStatusCreating WorkflowStatus = "CREATING"
WorkflowStatusActive WorkflowStatus = "ACTIVE"
WorkflowStatusUpdating WorkflowStatus = "UPDATING"
WorkflowStatusDeleted WorkflowStatus = "DELETED"
WorkflowStatusFailed WorkflowStatus = "FAILED"
WorkflowStatusInactive WorkflowStatus = "INACTIVE"
)
// Values returns all known values for WorkflowStatus. 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 (WorkflowStatus) Values() []WorkflowStatus {
return []WorkflowStatus{
"CREATING",
"ACTIVE",
"UPDATING",
"DELETED",
"FAILED",
"INACTIVE",
}
}
type WorkflowType string
// Enum values for WorkflowType
const (
WorkflowTypePrivate WorkflowType = "PRIVATE"
WorkflowTypeReady2run WorkflowType = "READY2RUN"
)
// Values returns all known values for WorkflowType. 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 (WorkflowType) Values() []WorkflowType {
return []WorkflowType{
"PRIVATE",
"READY2RUN",
}
}
| 718 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// You do not have sufficient access to perform this action.
type AccessDeniedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *AccessDeniedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *AccessDeniedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *AccessDeniedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "AccessDeniedException"
}
return *e.ErrorCodeOverride
}
func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request cannot be applied to the target resource in its current state.
type ConflictException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ConflictException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ConflictException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ConflictException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ConflictException"
}
return *e.ErrorCodeOverride
}
func (e *ConflictException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// An unexpected error occurred. Try the request again.
type InternalServerException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalServerException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServerException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServerException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServerException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The operation is not supported by Amazon Omics, or the API does not exist.
type NotSupportedOperationException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *NotSupportedOperationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *NotSupportedOperationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *NotSupportedOperationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "NotSupportedOperationException"
}
return *e.ErrorCodeOverride
}
func (e *NotSupportedOperationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The ranges specified in the request are not valid.
type RangeNotSatisfiableException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *RangeNotSatisfiableException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *RangeNotSatisfiableException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *RangeNotSatisfiableException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "RangeNotSatisfiableException"
}
return *e.ErrorCodeOverride
}
func (e *RangeNotSatisfiableException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request timed out.
type RequestTimeoutException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *RequestTimeoutException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *RequestTimeoutException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *RequestTimeoutException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "RequestTimeoutException"
}
return *e.ErrorCodeOverride
}
func (e *RequestTimeoutException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The target resource was not found in the current Region.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *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 {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request exceeds a service quota.
type ServiceQuotaExceededException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceQuotaExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceQuotaExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceQuotaExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceQuotaExceededException"
}
return *e.ErrorCodeOverride
}
func (e *ServiceQuotaExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request was denied due to request throttling.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ThrottlingException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ThrottlingException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ThrottlingException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ThrottlingException"
}
return *e.ErrorCodeOverride
}
func (e *ThrottlingException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The input fails to satisfy the constraints specified by an AWS service.
type ValidationException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ValidationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ValidationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ValidationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ValidationException"
}
return *e.ErrorCodeOverride
}
func (e *ValidationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 269 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
"time"
)
// A read set activation job filter.
type ActivateReadSetFilter struct {
// The filter's start date.
CreatedAfter *time.Time
// The filter's end date.
CreatedBefore *time.Time
// The filter's status.
Status ReadSetActivationJobStatus
noSmithyDocumentSerde
}
// A read set activation job.
type ActivateReadSetJobItem struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's ID.
//
// This member is required.
Id *string
// The job's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's status.
//
// This member is required.
Status ReadSetActivationJobStatus
// When the job completed.
CompletionTime *time.Time
noSmithyDocumentSerde
}
// A source for a read set activation job.
type ActivateReadSetSourceItem struct {
// The source's read set ID.
//
// This member is required.
ReadSetId *string
// The source's status.
//
// This member is required.
Status ReadSetActivationJobItemStatus
// The source's status message.
StatusMessage *string
noSmithyDocumentSerde
}
// Details about an imported annotation item.
type AnnotationImportItemDetail struct {
// The item's job status.
//
// This member is required.
JobStatus JobStatus
// The source file's location in Amazon S3.
//
// This member is required.
Source *string
noSmithyDocumentSerde
}
// A source for an annotation import job.
type AnnotationImportItemSource struct {
// The source file's location in Amazon S3.
//
// This member is required.
Source *string
noSmithyDocumentSerde
}
// An annotation import job.
type AnnotationImportJobItem struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's destination annotation store.
//
// This member is required.
DestinationName *string
// The job's ID.
//
// This member is required.
Id *string
// The job's service role ARN.
//
// This member is required.
RoleArn *string
// The job's status.
//
// This member is required.
Status JobStatus
// When the job was updated.
//
// This member is required.
UpdateTime *time.Time
// The annotation schema generated by the parsed annotation data.
AnnotationFields map[string]string
// When the job completed.
CompletionTime *time.Time
// The job's left normalization setting.
RunLeftNormalization bool
noSmithyDocumentSerde
}
// An annotation store.
type AnnotationStoreItem struct {
// The store's creation time.
//
// This member is required.
CreationTime *time.Time
// The store's description.
//
// This member is required.
Description *string
// The store's ID.
//
// This member is required.
Id *string
// The store's name.
//
// This member is required.
Name *string
// The store's genome reference.
//
// This member is required.
Reference ReferenceItem
// The store's server-side encryption (SSE) settings.
//
// This member is required.
SseConfig *SseConfig
// The store's status.
//
// This member is required.
Status StoreStatus
// The store's status message.
//
// This member is required.
StatusMessage *string
// The store's ARN.
//
// This member is required.
StoreArn *string
// The store's file format.
//
// This member is required.
StoreFormat StoreFormat
// The store's size in bytes.
//
// This member is required.
StoreSizeBytes *int64
// When the store was updated.
//
// This member is required.
UpdateTime *time.Time
noSmithyDocumentSerde
}
// Part of the response to the CompleteReadSetUpload API, including metadata.
type CompleteReadSetUploadPartListItem struct {
// A unique identifier used to confirm that parts are being added to the correct
// upload.
//
// This member is required.
Checksum *string
// A number identifying the part in a read set upload.
//
// This member is required.
PartNumber *int32
// The source file of the part being uploaded.
//
// This member is required.
PartSource ReadSetPartSource
noSmithyDocumentSerde
}
// A read set.
type ExportReadSet struct {
// The set's ID.
//
// This member is required.
ReadSetId *string
noSmithyDocumentSerde
}
// Details about a read set.
type ExportReadSetDetail struct {
// The set's ID.
//
// This member is required.
Id *string
// The set's status.
//
// This member is required.
Status ReadSetExportJobItemStatus
// The set's status message.
StatusMessage *string
noSmithyDocumentSerde
}
// An read set export job filter.
type ExportReadSetFilter struct {
// The filter's start date.
CreatedAfter *time.Time
// The filter's end date.
CreatedBefore *time.Time
// A status to filter on.
Status ReadSetExportJobStatus
noSmithyDocumentSerde
}
// Details about a read set export job.
type ExportReadSetJobDetail struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's destination in Amazon S3.
//
// This member is required.
Destination *string
// The job's ID.
//
// This member is required.
Id *string
// The job's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's status.
//
// This member is required.
Status ReadSetExportJobStatus
// When the job completed.
CompletionTime *time.Time
noSmithyDocumentSerde
}
// Details about a file.
type FileInformation struct {
// The file's content length.
ContentLength *int64
// The file's part size.
PartSize *int64
// The file's total parts.
TotalParts *int32
noSmithyDocumentSerde
}
// Formatting options for a file.
//
// The following types satisfy this interface:
//
// FormatOptionsMemberTsvOptions
// FormatOptionsMemberVcfOptions
type FormatOptions interface {
isFormatOptions()
}
// Options for a TSV file.
type FormatOptionsMemberTsvOptions struct {
Value TsvOptions
noSmithyDocumentSerde
}
func (*FormatOptionsMemberTsvOptions) isFormatOptions() {}
// Options for a VCF file.
type FormatOptionsMemberVcfOptions struct {
Value VcfOptions
noSmithyDocumentSerde
}
func (*FormatOptionsMemberVcfOptions) isFormatOptions() {}
// A filter for import read set jobs.
type ImportReadSetFilter struct {
// The filter's start date.
CreatedAfter *time.Time
// The filter's end date.
CreatedBefore *time.Time
// A status to filter on.
Status ReadSetImportJobStatus
noSmithyDocumentSerde
}
// An import read set job.
type ImportReadSetJobItem struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's ID.
//
// This member is required.
Id *string
// The job's service role ARN.
//
// This member is required.
RoleArn *string
// The job's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The job's status.
//
// This member is required.
Status ReadSetImportJobStatus
// When the job completed.
CompletionTime *time.Time
noSmithyDocumentSerde
}
// A source for an import read set job.
type ImportReadSetSourceItem struct {
// The source's sample ID.
//
// This member is required.
SampleId *string
// The source's file type.
//
// This member is required.
SourceFileType FileType
// The source files' location in Amazon S3.
//
// This member is required.
SourceFiles *SourceFiles
// The source's status.
//
// This member is required.
Status ReadSetImportJobItemStatus
// The source's subject ID.
//
// This member is required.
SubjectId *string
// The source's description.
Description *string
// Where the source originated.
GeneratedFrom *string
// The source's name.
Name *string
// The source's genome reference ARN.
ReferenceArn *string
// The source's status message.
StatusMessage *string
// The source's tags.
Tags map[string]string
noSmithyDocumentSerde
}
// A filter for import references.
type ImportReferenceFilter struct {
// The filter's start date.
CreatedAfter *time.Time
// The filter's end date.
CreatedBefore *time.Time
// A status to filter on.
Status ReferenceImportJobStatus
noSmithyDocumentSerde
}
// An import reference job.
type ImportReferenceJobItem struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's ID.
//
// This member is required.
Id *string
// The job's reference store ID.
//
// This member is required.
ReferenceStoreId *string
// The job's service role ARN.
//
// This member is required.
RoleArn *string
// The job's status.
//
// This member is required.
Status ReferenceImportJobStatus
// When the job completed.
CompletionTime *time.Time
noSmithyDocumentSerde
}
// An genome reference source.
type ImportReferenceSourceItem struct {
// The source's status.
//
// This member is required.
Status ReferenceImportJobItemStatus
// The source's description.
Description *string
// The source's name.
Name *string
// The source file's location in Amazon S3.
SourceFile *string
// The source's status message.
StatusMessage *string
// The source's tags.
Tags map[string]string
noSmithyDocumentSerde
}
// A filter for annotation import jobs.
type ListAnnotationImportJobsFilter struct {
// A status to filter on.
Status JobStatus
// A store name to filter on.
StoreName *string
noSmithyDocumentSerde
}
// A filter for annotation stores.
type ListAnnotationStoresFilter struct {
// A status to filter on.
Status StoreStatus
noSmithyDocumentSerde
}
// A filter for variant import jobs.
type ListVariantImportJobsFilter struct {
// A status to filter on.
Status JobStatus
// A store name to filter on.
StoreName *string
noSmithyDocumentSerde
}
// A filter for variant stores.
type ListVariantStoresFilter struct {
// A status to filter on.
Status StoreStatus
noSmithyDocumentSerde
}
// Part of the response to ListMultipartReadSetUploads, excluding completed and
// aborted multipart uploads.
type MultipartReadSetUploadListItem struct {
// The time stamp for when a direct upload was created.
//
// This member is required.
CreationTime *time.Time
// The source of an uploaded part.
//
// This member is required.
GeneratedFrom *string
// The source's reference ARN.
//
// This member is required.
ReferenceArn *string
// The read set source's sample ID.
//
// This member is required.
SampleId *string
// The sequence store ID used for the multipart upload.
//
// This member is required.
SequenceStoreId *string
// The type of file the read set originated from.
//
// This member is required.
SourceFileType FileType
// The read set source's subject ID.
//
// This member is required.
SubjectId *string
// The ID for the initiated multipart upload.
//
// This member is required.
UploadId *string
// The description of a read set.
Description *string
// The name of a read set.
Name *string
// Any tags you wish to add to a read set.
Tags map[string]string
noSmithyDocumentSerde
}
// Read options for an annotation import job.
type ReadOptions struct {
// The file's comment character.
Comment *string
// The file's encoding.
Encoding *string
// A character for escaping quotes in the file.
Escape *string
// Whether quotes need to be escaped in the file.
EscapeQuotes bool
// Whether the file has a header row.
Header bool
// A line separator for the file.
LineSep *string
// The file's quote character.
Quote *string
// Whether all values need to be quoted, or just those that contain quotes.
QuoteAll bool
// The file's field separator.
Sep *string
noSmithyDocumentSerde
}
// An error from a batch read set operation.
type ReadSetBatchError struct {
// The error's code.
//
// This member is required.
Code *string
// The error's ID.
//
// This member is required.
Id *string
// The error's message.
//
// This member is required.
Message *string
noSmithyDocumentSerde
}
// Files in a read set.
type ReadSetFiles struct {
// The files' index.
Index *FileInformation
// The location of the first file in Amazon S3.
Source1 *FileInformation
// The location of the second file in Amazon S3.
Source2 *FileInformation
noSmithyDocumentSerde
}
// A filter for read sets.
type ReadSetFilter struct {
// The filter's start date.
CreatedAfter *time.Time
// The filter's end date.
CreatedBefore *time.Time
// Where the source originated.
GeneratedFrom *string
// A name to filter on.
Name *string
// A genome reference ARN to filter on.
ReferenceArn *string
// The read set source's sample ID.
SampleId *string
// A status to filter on.
Status ReadSetStatus
// The read set source's subject ID.
SubjectId *string
noSmithyDocumentSerde
}
// A read set.
type ReadSetListItem struct {
// The read set's ARN.
//
// This member is required.
Arn *string
// When the read set was created.
//
// This member is required.
CreationTime *time.Time
// The read set's file type.
//
// This member is required.
FileType FileType
// The read set's ID.
//
// This member is required.
Id *string
// The read set's sequence store ID.
//
// This member is required.
SequenceStoreId *string
// The read set's status.
//
// This member is required.
Status ReadSetStatus
// The read set's description.
Description *string
// The read set's name.
Name *string
// The read set's genome reference ARN.
ReferenceArn *string
// The read set's sample ID.
SampleId *string
// Details about a sequence.
SequenceInformation *SequenceInformation
// The status for a read set. It provides more detail as to why the read set has a
// status.
StatusMessage *string
// The read set's subject ID.
SubjectId *string
noSmithyDocumentSerde
}
// Filter settings that select for read set upload parts of interest.
type ReadSetUploadPartListFilter struct {
// Filters for read set uploads after a specified time.
CreatedAfter *time.Time
// Filters for read set part uploads before a specified time.
CreatedBefore *time.Time
noSmithyDocumentSerde
}
// The metadata of a single part of a file that was added to a multipart upload. A
// list of these parts is returned in the response to the ListReadSetUploadParts
// API.
type ReadSetUploadPartListItem struct {
// A unique identifier used to confirm that parts are being added to the correct
// upload.
//
// This member is required.
Checksum *string
// The number identifying the part in an upload.
//
// This member is required.
PartNumber *int32
// The size of the the part in an upload.
//
// This member is required.
PartSize *int64
// The origin of the part being direct uploaded.
//
// This member is required.
PartSource ReadSetPartSource
// The time stamp for when a direct upload was created.
CreationTime *time.Time
// The time stamp for the most recent update to an uploaded part.
LastUpdatedTime *time.Time
noSmithyDocumentSerde
}
// A set of genome reference files.
type ReferenceFiles struct {
// The files' index.
Index *FileInformation
// The source file's location in Amazon S3.
Source *FileInformation
noSmithyDocumentSerde
}
// A filter for references.
type ReferenceFilter struct {
// The filter's start date.
CreatedAfter *time.Time
// The filter's end date.
CreatedBefore *time.Time
// An MD5 checksum to filter on.
Md5 *string
// A name to filter on.
Name *string
noSmithyDocumentSerde
}
// A genome reference.
//
// The following types satisfy this interface:
//
// ReferenceItemMemberReferenceArn
type ReferenceItem interface {
isReferenceItem()
}
// The reference's ARN.
type ReferenceItemMemberReferenceArn struct {
Value string
noSmithyDocumentSerde
}
func (*ReferenceItemMemberReferenceArn) isReferenceItem() {}
// A genome reference.
type ReferenceListItem struct {
// The reference's ARN.
//
// This member is required.
Arn *string
// When the reference was created.
//
// This member is required.
CreationTime *time.Time
// The reference's ID.
//
// This member is required.
Id *string
// The reference's MD5 checksum.
//
// This member is required.
Md5 *string
// The reference's store ID.
//
// This member is required.
ReferenceStoreId *string
// When the reference was updated.
//
// This member is required.
UpdateTime *time.Time
// The reference's description.
Description *string
// The reference's name.
Name *string
// The reference's status.
Status ReferenceStatus
noSmithyDocumentSerde
}
// Details about a reference store.
type ReferenceStoreDetail struct {
// The store's ARN.
//
// This member is required.
Arn *string
// When the store was created.
//
// This member is required.
CreationTime *time.Time
// The store's ID.
//
// This member is required.
Id *string
// The store's description.
Description *string
// The store's name.
Name *string
// The store's server-side encryption (SSE) settings.
SseConfig *SseConfig
noSmithyDocumentSerde
}
// A filter for reference stores.
type ReferenceStoreFilter struct {
// The filter's start date.
CreatedAfter *time.Time
// The filter's end date.
CreatedBefore *time.Time
// The name to filter on.
Name *string
noSmithyDocumentSerde
}
// A run group.
type RunGroupListItem struct {
// The group's ARN.
Arn *string
// When the group was created.
CreationTime *time.Time
// The group's ID.
Id *string
// The group's maximum CPU count setting.
MaxCpus *int32
// The group's maximum duration setting in minutes.
MaxDuration *int32
// The maximum GPUs that can be used by a run group.
MaxGpus *int32
// The group's maximum concurrent run setting.
MaxRuns *int32
// The group's name.
Name *string
noSmithyDocumentSerde
}
// A workflow run.
type RunListItem struct {
// The run's ARN.
Arn *string
// When the run was created.
CreationTime *time.Time
// The run's ID.
Id *string
// The run's name.
Name *string
// The run's priority.
Priority *int32
// When the run started.
StartTime *time.Time
// The run's status.
Status RunStatus
// When the run stopped.
StopTime *time.Time
// The run's storage capacity.
StorageCapacity *int32
// The run's workflow ID.
WorkflowId *string
noSmithyDocumentSerde
}
// Details about a sequence.
type SequenceInformation struct {
// The sequence's alignment setting.
Alignment *string
// Where the sequence originated.
GeneratedFrom *string
// The sequence's total base count.
TotalBaseCount *int64
// The sequence's total read count.
TotalReadCount *int64
noSmithyDocumentSerde
}
// Details about a sequence store.
type SequenceStoreDetail struct {
// The store's ARN.
//
// This member is required.
Arn *string
// When the store was created.
//
// This member is required.
CreationTime *time.Time
// The store's ID.
//
// This member is required.
Id *string
// The store's description.
Description *string
// An S3 location that is used to store files that have failed a direct upload.
FallbackLocation *string
// The store's name.
Name *string
// The store's server-side encryption (SSE) settings.
SseConfig *SseConfig
noSmithyDocumentSerde
}
// A filter for a sequence store.
type SequenceStoreFilter struct {
// The filter's start date.
CreatedAfter *time.Time
// The filter's end date.
CreatedBefore *time.Time
// A name to filter on.
Name *string
noSmithyDocumentSerde
}
// Source files for a sequence.
type SourceFiles struct {
// The location of the first file in Amazon S3.
//
// This member is required.
Source1 *string
// The location of the second file in Amazon S3.
Source2 *string
noSmithyDocumentSerde
}
// Server-side encryption (SSE) settings for a store.
type SseConfig struct {
// The encryption type.
//
// This member is required.
Type EncryptionType
// An encryption key ARN.
KeyArn *string
noSmithyDocumentSerde
}
// A source for a read set activation job.
type StartReadSetActivationJobSourceItem struct {
// The source's read set ID.
//
// This member is required.
ReadSetId *string
noSmithyDocumentSerde
}
// A source for a read set import job.
type StartReadSetImportJobSourceItem struct {
// The source's reference ARN.
//
// This member is required.
ReferenceArn *string
// The source's sample ID.
//
// This member is required.
SampleId *string
// The source's file type.
//
// This member is required.
SourceFileType FileType
// The source files' location in Amazon S3.
//
// This member is required.
SourceFiles *SourceFiles
// The source's subject ID.
//
// This member is required.
SubjectId *string
// The source's description.
Description *string
// Where the source originated.
GeneratedFrom *string
// The source's name.
Name *string
// The source's tags.
Tags map[string]string
noSmithyDocumentSerde
}
// A source for a reference import job.
type StartReferenceImportJobSourceItem struct {
// The source's name.
//
// This member is required.
Name *string
// The source file's location in Amazon S3.
//
// This member is required.
SourceFile *string
// The source's description.
Description *string
// The source's tags.
Tags map[string]string
noSmithyDocumentSerde
}
// Settings for a store.
//
// The following types satisfy this interface:
//
// StoreOptionsMemberTsvStoreOptions
type StoreOptions interface {
isStoreOptions()
}
// File settings for a TSV store.
type StoreOptionsMemberTsvStoreOptions struct {
Value TsvStoreOptions
noSmithyDocumentSerde
}
func (*StoreOptionsMemberTsvStoreOptions) isStoreOptions() {}
// A workflow run task.
type TaskListItem struct {
// The task's CPU count.
Cpus *int32
// When the task was created.
CreationTime *time.Time
// The number of Graphics Processing Units (GPU) specified for the task.
Gpus *int32
// The task's memory use in gigabyes.
Memory *int32
// The task's name.
Name *string
// When the task started.
StartTime *time.Time
// The task's status.
Status TaskStatus
// When the task stopped.
StopTime *time.Time
// The task's ID.
TaskId *string
noSmithyDocumentSerde
}
// Formatting options for a TSV file.
type TsvOptions struct {
// The file's read options.
ReadOptions *ReadOptions
noSmithyDocumentSerde
}
// File settings for a TSV store.
type TsvStoreOptions struct {
// The store's annotation type.
AnnotationType AnnotationType
// The store's header key to column name mapping.
FormatToHeader map[string]string
// The store's schema.
Schema []map[string]SchemaValueType
noSmithyDocumentSerde
}
// Details about an imported variant item.
type VariantImportItemDetail struct {
// The item's job status.
//
// This member is required.
JobStatus JobStatus
// The source file's location in Amazon S3.
//
// This member is required.
Source *string
// A message that provides additional context about a job
StatusMessage *string
noSmithyDocumentSerde
}
// A imported variant item's source.
type VariantImportItemSource struct {
// The source file's location in Amazon S3.
//
// This member is required.
Source *string
noSmithyDocumentSerde
}
// A variant import job.
type VariantImportJobItem struct {
// When the job was created.
//
// This member is required.
CreationTime *time.Time
// The job's destination variant store.
//
// This member is required.
DestinationName *string
// The job's ID.
//
// This member is required.
Id *string
// The job's service role ARN.
//
// This member is required.
RoleArn *string
// The job's status.
//
// This member is required.
Status JobStatus
// When the job was updated.
//
// This member is required.
UpdateTime *time.Time
// The annotation schema generated by the parsed annotation data.
AnnotationFields map[string]string
// When the job completed.
CompletionTime *time.Time
// The job's left normalization setting.
RunLeftNormalization bool
noSmithyDocumentSerde
}
// A variant store.
type VariantStoreItem struct {
// When the store was created.
//
// This member is required.
CreationTime *time.Time
// The store's description.
//
// This member is required.
Description *string
// The store's ID.
//
// This member is required.
Id *string
// The store's name.
//
// This member is required.
Name *string
// The store's genome reference.
//
// This member is required.
Reference ReferenceItem
// The store's server-side encryption (SSE) settings.
//
// This member is required.
SseConfig *SseConfig
// The store's status.
//
// This member is required.
Status StoreStatus
// The store's status message.
//
// This member is required.
StatusMessage *string
// The store's ARN.
//
// This member is required.
StoreArn *string
// The store's size in bytes.
//
// This member is required.
StoreSizeBytes *int64
// When the store was updated.
//
// This member is required.
UpdateTime *time.Time
noSmithyDocumentSerde
}
// Formatting options for a VCF file.
type VcfOptions struct {
// The file's ignore filter field setting.
IgnoreFilterField *bool
// The file's ignore qual field setting.
IgnoreQualField *bool
noSmithyDocumentSerde
}
// A workflow.
type WorkflowListItem struct {
// The workflow's ARN.
Arn *string
// When the workflow was created.
CreationTime *time.Time
// The workflow's digest.
Digest *string
// The workflow's ID.
Id *string
// Any metadata available for workflow. The information listed may vary depending
// on the workflow, and there may also be no metadata to return.
Metadata map[string]string
// The workflow's name.
Name *string
// The workflow's status.
Status WorkflowStatus
// The workflow's type.
Type WorkflowType
noSmithyDocumentSerde
}
// A workflow parameter.
type WorkflowParameter struct {
// The parameter's description.
Description *string
// Whether the parameter is optional.
Optional *bool
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
// UnknownUnionMember is returned when a union member is returned over the wire,
// but has an unknown tag.
type UnknownUnionMember struct {
Tag string
Value []byte
noSmithyDocumentSerde
}
func (*UnknownUnionMember) isFormatOptions() {}
func (*UnknownUnionMember) isReferenceItem() {}
func (*UnknownUnionMember) isStoreOptions() {}
| 1,484 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types_test
import (
"fmt"
"github.com/aws/aws-sdk-go-v2/service/omics/types"
)
func ExampleFormatOptions_outputUsage() {
var union types.FormatOptions
// type switches can be used to check the union value
switch v := union.(type) {
case *types.FormatOptionsMemberTsvOptions:
_ = v.Value // Value is types.TsvOptions
case *types.FormatOptionsMemberVcfOptions:
_ = v.Value // Value is types.VcfOptions
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.VcfOptions
var _ *types.TsvOptions
func ExampleReferenceItem_outputUsage() {
var union types.ReferenceItem
// type switches can be used to check the union value
switch v := union.(type) {
case *types.ReferenceItemMemberReferenceArn:
_ = v.Value // Value is string
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *string
func ExampleStoreOptions_outputUsage() {
var union types.StoreOptions
// type switches can be used to check the union value
switch v := union.(type) {
case *types.StoreOptionsMemberTsvStoreOptions:
_ = v.Value // Value is types.TsvStoreOptions
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.TsvStoreOptions
| 67 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "OpenSearch"
const ServiceAPIVersion = "2021-01-01"
// Client provides the API client to make operations call for Amazon OpenSearch
// Service.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "opensearch", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 435 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Allows the destination Amazon OpenSearch Service domain owner to accept an
// inbound cross-cluster search connection request. For more information, see
// Cross-cluster search for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/cross-cluster-search.html)
// .
func (c *Client) AcceptInboundConnection(ctx context.Context, params *AcceptInboundConnectionInput, optFns ...func(*Options)) (*AcceptInboundConnectionOutput, error) {
if params == nil {
params = &AcceptInboundConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AcceptInboundConnection", params, optFns, c.addOperationAcceptInboundConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AcceptInboundConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the AcceptInboundConnection operation.
type AcceptInboundConnectionInput struct {
// The ID of the inbound connection to accept.
//
// This member is required.
ConnectionId *string
noSmithyDocumentSerde
}
// Contains details about the accepted inbound connection.
type AcceptInboundConnectionOutput struct {
// Information about the accepted inbound connection.
Connection *types.InboundConnection
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAcceptInboundConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAcceptInboundConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAcceptInboundConnection{}, 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 = addOpAcceptInboundConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAcceptInboundConnection(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAcceptInboundConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "AcceptInboundConnection",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Attaches tags to an existing Amazon OpenSearch Service domain. Tags are a set
// of case-sensitive key-value pairs. A domain can have up to 10 tags. For more
// information, see Tagging Amazon OpenSearch Service domains (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/managedomains-awsresourcetagging.html)
// .
func (c *Client) AddTags(ctx context.Context, params *AddTagsInput, optFns ...func(*Options)) (*AddTagsOutput, error) {
if params == nil {
params = &AddTagsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AddTags", params, optFns, c.addOperationAddTagsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AddTagsOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the AddTags operation. Specifies the tags to
// attach to the domain.
type AddTagsInput struct {
// Amazon Resource Name (ARN) for the OpenSearch Service domain to which you want
// to attach resource tags.
//
// This member is required.
ARN *string
// List of resource tags.
//
// This member is required.
TagList []types.Tag
noSmithyDocumentSerde
}
type AddTagsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAddTagsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAddTags{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAddTags{}, 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 = addOpAddTagsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAddTags(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAddTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "AddTags",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Associates a package with an Amazon OpenSearch Service domain. For more
// information, see Custom packages for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/custom-packages.html)
// .
func (c *Client) AssociatePackage(ctx context.Context, params *AssociatePackageInput, optFns ...func(*Options)) (*AssociatePackageOutput, error) {
if params == nil {
params = &AssociatePackageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AssociatePackage", params, optFns, c.addOperationAssociatePackageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AssociatePackageOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to the AssociatePackage operation.
type AssociatePackageInput struct {
// Name of the domain to associate the package with.
//
// This member is required.
DomainName *string
// Internal ID of the package to associate with a domain. Use DescribePackages to
// find this value.
//
// This member is required.
PackageID *string
noSmithyDocumentSerde
}
// Container for the response returned by the AssociatePackage operation.
type AssociatePackageOutput struct {
// Information about a package that is associated with a domain.
DomainPackageDetails *types.DomainPackageDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAssociatePackageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAssociatePackage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAssociatePackage{}, 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 = addOpAssociatePackageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAssociatePackage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAssociatePackage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "AssociatePackage",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides access to an Amazon OpenSearch Service domain through the use of an
// interface VPC endpoint.
func (c *Client) AuthorizeVpcEndpointAccess(ctx context.Context, params *AuthorizeVpcEndpointAccessInput, optFns ...func(*Options)) (*AuthorizeVpcEndpointAccessOutput, error) {
if params == nil {
params = &AuthorizeVpcEndpointAccessInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AuthorizeVpcEndpointAccess", params, optFns, c.addOperationAuthorizeVpcEndpointAccessMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AuthorizeVpcEndpointAccessOutput)
out.ResultMetadata = metadata
return out, nil
}
type AuthorizeVpcEndpointAccessInput struct {
// The Amazon Web Services account ID to grant access to.
//
// This member is required.
Account *string
// The name of the OpenSearch Service domain to provide access to.
//
// This member is required.
DomainName *string
noSmithyDocumentSerde
}
type AuthorizeVpcEndpointAccessOutput struct {
// Information about the Amazon Web Services account or service that was provided
// access to the domain.
//
// This member is required.
AuthorizedPrincipal *types.AuthorizedPrincipal
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAuthorizeVpcEndpointAccessMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAuthorizeVpcEndpointAccess{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAuthorizeVpcEndpointAccess{}, 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 = addOpAuthorizeVpcEndpointAccessValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAuthorizeVpcEndpointAccess(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAuthorizeVpcEndpointAccess(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "AuthorizeVpcEndpointAccess",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Cancels a scheduled service software update for an Amazon OpenSearch Service
// domain. You can only perform this operation before the AutomatedUpdateDate and
// when the domain's UpdateStatus is PENDING_UPDATE . For more information, see
// Service software updates in Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/service-software.html)
// .
func (c *Client) CancelServiceSoftwareUpdate(ctx context.Context, params *CancelServiceSoftwareUpdateInput, optFns ...func(*Options)) (*CancelServiceSoftwareUpdateOutput, error) {
if params == nil {
params = &CancelServiceSoftwareUpdateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CancelServiceSoftwareUpdate", params, optFns, c.addOperationCancelServiceSoftwareUpdateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CancelServiceSoftwareUpdateOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to cancel a service software update.
type CancelServiceSoftwareUpdateInput struct {
// Name of the OpenSearch Service domain that you want to cancel the service
// software update on.
//
// This member is required.
DomainName *string
noSmithyDocumentSerde
}
// Container for the response to a CancelServiceSoftwareUpdate operation. Contains
// the status of the update.
type CancelServiceSoftwareUpdateOutput struct {
// Container for the state of your domain relative to the latest service software.
ServiceSoftwareOptions *types.ServiceSoftwareOptions
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCancelServiceSoftwareUpdateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCancelServiceSoftwareUpdate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCancelServiceSoftwareUpdate{}, 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 = addOpCancelServiceSoftwareUpdateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCancelServiceSoftwareUpdate(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCancelServiceSoftwareUpdate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "CancelServiceSoftwareUpdate",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Amazon OpenSearch Service domain. For more information, see Creating
// and managing Amazon OpenSearch Service domains (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/createupdatedomains.html)
// .
func (c *Client) CreateDomain(ctx context.Context, params *CreateDomainInput, optFns ...func(*Options)) (*CreateDomainOutput, error) {
if params == nil {
params = &CreateDomainInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDomain", params, optFns, c.addOperationCreateDomainMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDomainOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDomainInput struct {
// Name of the OpenSearch Service domain to create. Domain names are unique across
// the domains owned by an account within an Amazon Web Services Region.
//
// This member is required.
DomainName *string
// Identity and Access Management (IAM) policy document specifying the access
// policies for the new domain.
AccessPolicies *string
// Key-value pairs to specify advanced configuration options. The following
// key-value pairs are supported:
// - "rest.action.multi.allow_explicit_index": "true" | "false" - Note the use of
// a string rather than a boolean. Specifies whether explicit references to indexes
// are allowed inside the body of HTTP requests. If you want to configure access
// policies for domain sub-resources, such as specific indexes and domain APIs, you
// must disable this property. Default is true.
// - "indices.fielddata.cache.size": "80" - Note the use of a string rather than
// a boolean. Specifies the percentage of heap space allocated to field data.
// Default is unbounded.
// - "indices.query.bool.max_clause_count": "1024" - Note the use of a string
// rather than a boolean. Specifies the maximum number of clauses allowed in a
// Lucene boolean query. Default is 1,024. Queries with more than the permitted
// number of clauses result in a TooManyClauses error.
// - "override_main_response_version": "true" | "false" - Note the use of a
// string rather than a boolean. Specifies whether the domain reports its version
// as 7.10 to allow Elasticsearch OSS clients and plugins to continue working with
// it. Default is false when creating a domain and true when upgrading a domain.
// For more information, see Advanced cluster parameters (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/createupdatedomains.html#createdomain-configure-advanced-options)
// .
AdvancedOptions map[string]string
// Options for fine-grained access control.
AdvancedSecurityOptions *types.AdvancedSecurityOptionsInput
// Options for Auto-Tune.
AutoTuneOptions *types.AutoTuneOptionsInput
// Container for the cluster configuration of a domain.
ClusterConfig *types.ClusterConfig
// Key-value pairs to configure Amazon Cognito authentication. For more
// information, see Configuring Amazon Cognito authentication for OpenSearch
// Dashboards (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/cognito-auth.html)
// .
CognitoOptions *types.CognitoOptions
// Additional options for the domain endpoint, such as whether to require HTTPS
// for all traffic.
DomainEndpointOptions *types.DomainEndpointOptions
// Container for the parameters required to enable EBS-based storage for an
// OpenSearch Service domain.
EBSOptions *types.EBSOptions
// Key-value pairs to enable encryption at rest.
EncryptionAtRestOptions *types.EncryptionAtRestOptions
// String of format Elasticsearch_X.Y or OpenSearch_X.Y to specify the engine
// version for the OpenSearch Service domain. For example, OpenSearch_1.0 or
// Elasticsearch_7.9 . For more information, see Creating and managing Amazon
// OpenSearch Service domains (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/createupdatedomains.html#createdomains)
// .
EngineVersion *string
// Key-value pairs to configure log publishing.
LogPublishingOptions map[string]types.LogPublishingOption
// Enables node-to-node encryption.
NodeToNodeEncryptionOptions *types.NodeToNodeEncryptionOptions
// Specifies a daily 10-hour time block during which OpenSearch Service can
// perform configuration changes on the domain, including service software updates
// and Auto-Tune enhancements that require a blue/green deployment. If no options
// are specified, the default start time of 10:00 P.M. local time (for the Region
// that the domain is created in) is used.
OffPeakWindowOptions *types.OffPeakWindowOptions
// DEPRECATED. Container for the parameters required to configure automated
// snapshots of domain indexes.
SnapshotOptions *types.SnapshotOptions
// Software update options for the domain.
SoftwareUpdateOptions *types.SoftwareUpdateOptions
// List of tags to add to the domain upon creation.
TagList []types.Tag
// Container for the values required to configure VPC access domains. If you don't
// specify these values, OpenSearch Service creates the domain with a public
// endpoint. For more information, see Launching your Amazon OpenSearch Service
// domains using a VPC (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/vpc.html)
// .
VPCOptions *types.VPCOptions
noSmithyDocumentSerde
}
// The result of a CreateDomain operation. Contains the status of the newly
// created domain.
type CreateDomainOutput struct {
// The status of the newly created domain.
DomainStatus *types.DomainStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDomainMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateDomain{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateDomain{}, 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 = addOpCreateDomainValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDomain(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDomain(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "CreateDomain",
}
}
| 219 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new cross-cluster search connection from a source Amazon OpenSearch
// Service domain to a destination domain. For more information, see Cross-cluster
// search for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/cross-cluster-search.html)
// .
func (c *Client) CreateOutboundConnection(ctx context.Context, params *CreateOutboundConnectionInput, optFns ...func(*Options)) (*CreateOutboundConnectionOutput, error) {
if params == nil {
params = &CreateOutboundConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateOutboundConnection", params, optFns, c.addOperationCreateOutboundConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateOutboundConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the CreateOutboundConnection operation.
type CreateOutboundConnectionInput struct {
// Name of the connection.
//
// This member is required.
ConnectionAlias *string
// Name and Region of the source (local) domain.
//
// This member is required.
LocalDomainInfo *types.DomainInformationContainer
// Name and Region of the destination (remote) domain.
//
// This member is required.
RemoteDomainInfo *types.DomainInformationContainer
// The connection mode.
ConnectionMode types.ConnectionMode
// The ConnectionProperties for the outbound connection.
ConnectionProperties *types.ConnectionProperties
noSmithyDocumentSerde
}
// The result of a CreateOutboundConnection request. Contains details about the
// newly created cross-cluster connection.
type CreateOutboundConnectionOutput struct {
// Name of the connection.
ConnectionAlias *string
// The unique identifier for the created outbound connection, which is used for
// subsequent operations on the connection.
ConnectionId *string
// The connection mode.
ConnectionMode types.ConnectionMode
// The ConnectionProperties for the newly created connection.
ConnectionProperties *types.ConnectionProperties
// The status of the connection.
ConnectionStatus *types.OutboundConnectionStatus
// Information about the source (local) domain.
LocalDomainInfo *types.DomainInformationContainer
// Information about the destination (remote) domain.
RemoteDomainInfo *types.DomainInformationContainer
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateOutboundConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateOutboundConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateOutboundConnection{}, 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 = addOpCreateOutboundConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateOutboundConnection(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateOutboundConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "CreateOutboundConnection",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a package for use with Amazon OpenSearch Service domains. For more
// information, see Custom packages for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/custom-packages.html)
// .
func (c *Client) CreatePackage(ctx context.Context, params *CreatePackageInput, optFns ...func(*Options)) (*CreatePackageOutput, error) {
if params == nil {
params = &CreatePackageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreatePackage", params, optFns, c.addOperationCreatePackageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreatePackageOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for request parameters to the CreatePackage operation.
type CreatePackageInput struct {
// Unique name for the package.
//
// This member is required.
PackageName *string
// The Amazon S3 location from which to import the package.
//
// This member is required.
PackageSource *types.PackageSource
// The type of package.
//
// This member is required.
PackageType types.PackageType
// Description of the package.
PackageDescription *string
noSmithyDocumentSerde
}
// Container for the response returned by the CreatePackage operation.
type CreatePackageOutput struct {
// Basic information about an OpenSearch Service package.
PackageDetails *types.PackageDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreatePackageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreatePackage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreatePackage{}, 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 = addOpCreatePackageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreatePackage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreatePackage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "CreatePackage",
}
}
| 142 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Amazon OpenSearch Service-managed VPC endpoint.
func (c *Client) CreateVpcEndpoint(ctx context.Context, params *CreateVpcEndpointInput, optFns ...func(*Options)) (*CreateVpcEndpointOutput, error) {
if params == nil {
params = &CreateVpcEndpointInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateVpcEndpoint", params, optFns, c.addOperationCreateVpcEndpointMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateVpcEndpointOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateVpcEndpointInput struct {
// The Amazon Resource Name (ARN) of the domain to create the endpoint for.
//
// This member is required.
DomainArn *string
// Options to specify the subnets and security groups for the endpoint.
//
// This member is required.
VpcOptions *types.VPCOptions
// Unique, case-sensitive identifier to ensure idempotency of the request.
ClientToken *string
noSmithyDocumentSerde
}
type CreateVpcEndpointOutput struct {
// Information about the newly created VPC endpoint.
//
// This member is required.
VpcEndpoint *types.VpcEndpoint
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateVpcEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateVpcEndpoint{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateVpcEndpoint{}, 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 = addOpCreateVpcEndpointValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateVpcEndpoint(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateVpcEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "CreateVpcEndpoint",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Amazon OpenSearch Service domain and all of its data. You can't
// recover a domain after you delete it.
func (c *Client) DeleteDomain(ctx context.Context, params *DeleteDomainInput, optFns ...func(*Options)) (*DeleteDomainOutput, error) {
if params == nil {
params = &DeleteDomainInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDomain", params, optFns, c.addOperationDeleteDomainMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDomainOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DeleteDomain operation.
type DeleteDomainInput struct {
// The name of the domain you want to permanently delete.
//
// This member is required.
DomainName *string
noSmithyDocumentSerde
}
// The results of a DeleteDomain request. Contains the status of the pending
// deletion, or a "domain not found" error if the domain and all of its resources
// have been deleted.
type DeleteDomainOutput struct {
// The status of the domain being deleted.
DomainStatus *types.DomainStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDomainMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteDomain{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteDomain{}, 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 = addOpDeleteDomainValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDomain(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDomain(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DeleteDomain",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Allows the destination Amazon OpenSearch Service domain owner to delete an
// existing inbound cross-cluster search connection. For more information, see
// Cross-cluster search for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/cross-cluster-search.html)
// .
func (c *Client) DeleteInboundConnection(ctx context.Context, params *DeleteInboundConnectionInput, optFns ...func(*Options)) (*DeleteInboundConnectionOutput, error) {
if params == nil {
params = &DeleteInboundConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteInboundConnection", params, optFns, c.addOperationDeleteInboundConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteInboundConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DeleteInboundConnection operation.
type DeleteInboundConnectionInput struct {
// The ID of the inbound connection to permanently delete.
//
// This member is required.
ConnectionId *string
noSmithyDocumentSerde
}
// The results of a DeleteInboundConnection operation. Contains details about the
// deleted inbound connection.
type DeleteInboundConnectionOutput struct {
// The deleted inbound connection.
Connection *types.InboundConnection
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteInboundConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteInboundConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteInboundConnection{}, 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 = addOpDeleteInboundConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteInboundConnection(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteInboundConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DeleteInboundConnection",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Allows the source Amazon OpenSearch Service domain owner to delete an existing
// outbound cross-cluster search connection. For more information, see
// Cross-cluster search for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/cross-cluster-search.html)
// .
func (c *Client) DeleteOutboundConnection(ctx context.Context, params *DeleteOutboundConnectionInput, optFns ...func(*Options)) (*DeleteOutboundConnectionOutput, error) {
if params == nil {
params = &DeleteOutboundConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteOutboundConnection", params, optFns, c.addOperationDeleteOutboundConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteOutboundConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DeleteOutboundConnection operation.
type DeleteOutboundConnectionInput struct {
// The ID of the outbound connection you want to permanently delete.
//
// This member is required.
ConnectionId *string
noSmithyDocumentSerde
}
// Details about the deleted outbound connection.
type DeleteOutboundConnectionOutput struct {
// The deleted inbound connection.
Connection *types.OutboundConnection
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteOutboundConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteOutboundConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteOutboundConnection{}, 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 = addOpDeleteOutboundConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteOutboundConnection(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteOutboundConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DeleteOutboundConnection",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Amazon OpenSearch Service package. For more information, see Custom
// packages for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/custom-packages.html)
// .
func (c *Client) DeletePackage(ctx context.Context, params *DeletePackageInput, optFns ...func(*Options)) (*DeletePackageOutput, error) {
if params == nil {
params = &DeletePackageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeletePackage", params, optFns, c.addOperationDeletePackageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeletePackageOutput)
out.ResultMetadata = metadata
return out, nil
}
// Deletes a package from OpenSearch Service. The package can't be associated with
// any OpenSearch Service domain.
type DeletePackageInput struct {
// The internal ID of the package you want to delete. Use DescribePackages to find
// this value.
//
// This member is required.
PackageID *string
noSmithyDocumentSerde
}
// Container for the response parameters to the DeletePackage operation.
type DeletePackageOutput struct {
// Information about the deleted package.
PackageDetails *types.PackageDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeletePackageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeletePackage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeletePackage{}, 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 = addOpDeletePackageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeletePackage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeletePackage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DeletePackage",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Amazon OpenSearch Service-managed interface VPC endpoint.
func (c *Client) DeleteVpcEndpoint(ctx context.Context, params *DeleteVpcEndpointInput, optFns ...func(*Options)) (*DeleteVpcEndpointOutput, error) {
if params == nil {
params = &DeleteVpcEndpointInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteVpcEndpoint", params, optFns, c.addOperationDeleteVpcEndpointMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteVpcEndpointOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteVpcEndpointInput struct {
// The unique identifier of the endpoint.
//
// This member is required.
VpcEndpointId *string
noSmithyDocumentSerde
}
type DeleteVpcEndpointOutput struct {
// Information about the deleted endpoint, including its current status ( DELETING
// or DELETE_FAILED ).
//
// This member is required.
VpcEndpointSummary *types.VpcEndpointSummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteVpcEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteVpcEndpoint{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteVpcEndpoint{}, 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 = addOpDeleteVpcEndpointValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteVpcEndpoint(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteVpcEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DeleteVpcEndpoint",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the domain configuration for the specified Amazon OpenSearch Service
// domain, including the domain ID, domain service endpoint, and domain ARN.
func (c *Client) DescribeDomain(ctx context.Context, params *DescribeDomainInput, optFns ...func(*Options)) (*DescribeDomainOutput, error) {
if params == nil {
params = &DescribeDomainInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDomain", params, optFns, c.addOperationDescribeDomainMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDomainOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeDomain operation.
type DescribeDomainInput struct {
// The name of the domain that you want information about.
//
// This member is required.
DomainName *string
noSmithyDocumentSerde
}
// Contains the status of the domain specified in the request.
type DescribeDomainOutput struct {
// List that contains the status of each specified OpenSearch Service domain.
//
// This member is required.
DomainStatus *types.DomainStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDomainMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDomain{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDomain{}, 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 = addOpDescribeDomainValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDomain(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDomain(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeDomain",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the list of optimizations that Auto-Tune has made to an Amazon
// OpenSearch Service domain. For more information, see Auto-Tune for Amazon
// OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/auto-tune.html)
// .
func (c *Client) DescribeDomainAutoTunes(ctx context.Context, params *DescribeDomainAutoTunesInput, optFns ...func(*Options)) (*DescribeDomainAutoTunesOutput, error) {
if params == nil {
params = &DescribeDomainAutoTunesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDomainAutoTunes", params, optFns, c.addOperationDescribeDomainAutoTunesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDomainAutoTunesOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeDomainAutoTunes operation.
type DescribeDomainAutoTunesInput struct {
// Name of the domain that you want Auto-Tune details about.
//
// This member is required.
DomainName *string
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial DescribeDomainAutoTunes operation returns a nextToken , you can
// include the returned nextToken in subsequent DescribeDomainAutoTunes
// operations, which returns results in the next page.
NextToken *string
noSmithyDocumentSerde
}
// The result of a DescribeDomainAutoTunes request.
type DescribeDomainAutoTunesOutput struct {
// The list of setting adjustments that Auto-Tune has made to the domain.
AutoTunes []types.AutoTune
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDomainAutoTunesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDomainAutoTunes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDomainAutoTunes{}, 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 = addOpDescribeDomainAutoTunesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDomainAutoTunes(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribeDomainAutoTunesAPIClient is a client that implements the
// DescribeDomainAutoTunes operation.
type DescribeDomainAutoTunesAPIClient interface {
DescribeDomainAutoTunes(context.Context, *DescribeDomainAutoTunesInput, ...func(*Options)) (*DescribeDomainAutoTunesOutput, error)
}
var _ DescribeDomainAutoTunesAPIClient = (*Client)(nil)
// DescribeDomainAutoTunesPaginatorOptions is the paginator options for
// DescribeDomainAutoTunes
type DescribeDomainAutoTunesPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeDomainAutoTunesPaginator is a paginator for DescribeDomainAutoTunes
type DescribeDomainAutoTunesPaginator struct {
options DescribeDomainAutoTunesPaginatorOptions
client DescribeDomainAutoTunesAPIClient
params *DescribeDomainAutoTunesInput
nextToken *string
firstPage bool
}
// NewDescribeDomainAutoTunesPaginator returns a new
// DescribeDomainAutoTunesPaginator
func NewDescribeDomainAutoTunesPaginator(client DescribeDomainAutoTunesAPIClient, params *DescribeDomainAutoTunesInput, optFns ...func(*DescribeDomainAutoTunesPaginatorOptions)) *DescribeDomainAutoTunesPaginator {
if params == nil {
params = &DescribeDomainAutoTunesInput{}
}
options := DescribeDomainAutoTunesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeDomainAutoTunesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeDomainAutoTunesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeDomainAutoTunes page.
func (p *DescribeDomainAutoTunesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeDomainAutoTunesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.DescribeDomainAutoTunes(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeDomainAutoTunes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeDomainAutoTunes",
}
}
| 234 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about the current blue/green deployment happening on an
// Amazon OpenSearch Service domain. For more information, see Making
// configuration changes in Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/managedomains-configuration-changes.html)
// .
func (c *Client) DescribeDomainChangeProgress(ctx context.Context, params *DescribeDomainChangeProgressInput, optFns ...func(*Options)) (*DescribeDomainChangeProgressOutput, error) {
if params == nil {
params = &DescribeDomainChangeProgressInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDomainChangeProgress", params, optFns, c.addOperationDescribeDomainChangeProgressMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDomainChangeProgressOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeDomainChangeProgress operation.
type DescribeDomainChangeProgressInput struct {
// The name of the domain to get progress information for.
//
// This member is required.
DomainName *string
// The specific change ID for which you want to get progress information. If
// omitted, the request returns information about the most recent configuration
// change.
ChangeId *string
noSmithyDocumentSerde
}
// The result of a DescribeDomainChangeProgress request. Contains progress
// information for the requested domain change.
type DescribeDomainChangeProgressOutput struct {
// Container for information about the stages of a configuration change happening
// on a domain.
ChangeProgressStatus *types.ChangeProgressStatusDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDomainChangeProgressMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDomainChangeProgress{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDomainChangeProgress{}, 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 = addOpDescribeDomainChangeProgressValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDomainChangeProgress(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDomainChangeProgress(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeDomainChangeProgress",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the configuration of an Amazon OpenSearch Service domain.
func (c *Client) DescribeDomainConfig(ctx context.Context, params *DescribeDomainConfigInput, optFns ...func(*Options)) (*DescribeDomainConfigOutput, error) {
if params == nil {
params = &DescribeDomainConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDomainConfig", params, optFns, c.addOperationDescribeDomainConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDomainConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeDomainConfig operation.
type DescribeDomainConfigInput struct {
// Name of the OpenSearch Service domain configuration that you want to describe.
//
// This member is required.
DomainName *string
noSmithyDocumentSerde
}
// Contains the configuration information of the requested domain.
type DescribeDomainConfigOutput struct {
// Container for the configuration of the OpenSearch Service domain.
//
// This member is required.
DomainConfig *types.DomainConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDomainConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDomainConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDomainConfig{}, 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 = addOpDescribeDomainConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDomainConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDomainConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeDomainConfig",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about domain and node health, the standby Availability
// Zone, number of nodes per Availability Zone, and shard count per node.
func (c *Client) DescribeDomainHealth(ctx context.Context, params *DescribeDomainHealthInput, optFns ...func(*Options)) (*DescribeDomainHealthOutput, error) {
if params == nil {
params = &DescribeDomainHealthInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDomainHealth", params, optFns, c.addOperationDescribeDomainHealthMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDomainHealthOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeDomainHealth operation.
type DescribeDomainHealthInput struct {
// The name of the domain.
//
// This member is required.
DomainName *string
noSmithyDocumentSerde
}
// The result of a DescribeDomainHealth request. Contains health information for
// the requested domain.
type DescribeDomainHealthOutput struct {
// The number of active Availability Zones configured for the domain. If the
// service is unable to fetch this information, it will return NotAvailable .
ActiveAvailabilityZoneCount *string
// The number of Availability Zones configured for the domain. If the service is
// unable to fetch this information, it will return NotAvailable .
AvailabilityZoneCount *string
// The current health status of your cluster.
// - Red - At least one primary shard is not allocated to any node.
// - Yellow - All primary shards are allocated to nodes, but some replicas
// aren’t.
// - Green - All primary shards and their replicas are allocated to nodes.
// - NotAvailable - Unable to retrieve cluster health.
ClusterHealth types.DomainHealth
// The number of data nodes configured for the domain. If the service is unable to
// fetch this information, it will return NotAvailable .
DataNodeCount *string
// A boolean that indicates if dedicated master nodes are activated for the domain.
DedicatedMaster *bool
// The current state of the domain.
// - Processing - The domain has updates in progress.
// - Active - Requested changes have been processed and deployed to the domain.
DomainState types.DomainState
// A list of EnvironmentInfo for the domain.
EnvironmentInformation []types.EnvironmentInfo
// The number of nodes that can be elected as a master node. If dedicated master
// nodes is turned on, this value is the number of dedicated master nodes
// configured for the domain. If the service is unable to fetch this information,
// it will return NotAvailable .
MasterEligibleNodeCount *string
// Indicates whether the domain has an elected master node.
// - Available - The domain has an elected master node.
// - UnAvailable - The master node hasn't yet been elected, and a quorum to
// elect a new master node hasn't been reached.
MasterNode types.MasterNodeStatus
// The number of standby Availability Zones configured for the domain. If the
// service is unable to fetch this information, it will return NotAvailable .
StandByAvailabilityZoneCount *string
// The total number of primary and replica shards for the domain.
TotalShards *string
// The total number of primary and replica shards not allocated to any of the
// nodes for the cluster.
TotalUnAssignedShards *string
// The number of warm nodes configured for the domain.
WarmNodeCount *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDomainHealthMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDomainHealth{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDomainHealth{}, 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 = addOpDescribeDomainHealthValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDomainHealth(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDomainHealth(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeDomainHealth",
}
}
| 183 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about domain and nodes, including data nodes, master nodes,
// ultrawarm nodes, Availability Zone(s), standby nodes, node configurations, and
// node states.
func (c *Client) DescribeDomainNodes(ctx context.Context, params *DescribeDomainNodesInput, optFns ...func(*Options)) (*DescribeDomainNodesOutput, error) {
if params == nil {
params = &DescribeDomainNodesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDomainNodes", params, optFns, c.addOperationDescribeDomainNodesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDomainNodesOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeDomainNodes operation.
type DescribeDomainNodesInput struct {
// The name of the domain.
//
// This member is required.
DomainName *string
noSmithyDocumentSerde
}
// The result of a DescribeDomainNodes request. Contains information about the
// nodes on the requested domain.
type DescribeDomainNodesOutput struct {
// Contains nodes information list DomainNodesStatusList with details about the
// all nodes on the requested domain.
DomainNodesStatusList []types.DomainNodesStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDomainNodesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDomainNodes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDomainNodes{}, 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 = addOpDescribeDomainNodesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDomainNodes(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDomainNodes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeDomainNodes",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns domain configuration information about the specified Amazon OpenSearch
// Service domains.
func (c *Client) DescribeDomains(ctx context.Context, params *DescribeDomainsInput, optFns ...func(*Options)) (*DescribeDomainsOutput, error) {
if params == nil {
params = &DescribeDomainsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDomains", params, optFns, c.addOperationDescribeDomainsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDomainsOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeDomains operation.
type DescribeDomainsInput struct {
// Array of OpenSearch Service domain names that you want information about. If
// you don't specify any domains, OpenSearch Service returns information about all
// domains owned by the account.
//
// This member is required.
DomainNames []string
noSmithyDocumentSerde
}
// Contains the status of the specified domains or all domains owned by the
// account.
type DescribeDomainsOutput struct {
// The status of the requested domains.
//
// This member is required.
DomainStatusList []types.DomainStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDomainsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDomains{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDomains{}, 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 = addOpDescribeDomainsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDomains(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDomains(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeDomains",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the progress of a pre-update dry run analysis on an Amazon OpenSearch
// Service domain. For more information, see Determining whether a change will
// cause a blue/green deployment (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/managedomains-configuration-changes#dryrun)
// .
func (c *Client) DescribeDryRunProgress(ctx context.Context, params *DescribeDryRunProgressInput, optFns ...func(*Options)) (*DescribeDryRunProgressOutput, error) {
if params == nil {
params = &DescribeDryRunProgressInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDryRunProgress", params, optFns, c.addOperationDescribeDryRunProgressMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDryRunProgressOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDryRunProgressInput struct {
// The name of the domain.
//
// This member is required.
DomainName *string
// The unique identifier of the dry run.
DryRunId *string
// Whether to include the configuration of the dry run in the response. The
// configuration specifies the updates that you're planning to make on the domain.
LoadDryRunConfig *bool
noSmithyDocumentSerde
}
type DescribeDryRunProgressOutput struct {
// Details about the changes you're planning to make on the domain.
DryRunConfig *types.DomainStatus
// The current status of the dry run, including any validation errors.
DryRunProgressStatus *types.DryRunProgressStatus
// The results of the dry run.
DryRunResults *types.DryRunResults
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDryRunProgressMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDryRunProgress{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDryRunProgress{}, 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 = addOpDescribeDryRunProgressValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDryRunProgress(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDryRunProgress(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeDryRunProgress",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all the inbound cross-cluster search connections for a destination
// (remote) Amazon OpenSearch Service domain. For more information, see
// Cross-cluster search for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/cross-cluster-search.html)
// .
func (c *Client) DescribeInboundConnections(ctx context.Context, params *DescribeInboundConnectionsInput, optFns ...func(*Options)) (*DescribeInboundConnectionsOutput, error) {
if params == nil {
params = &DescribeInboundConnectionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeInboundConnections", params, optFns, c.addOperationDescribeInboundConnectionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeInboundConnectionsOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeInboundConnections operation.
type DescribeInboundConnectionsInput struct {
// A list of filters used to match properties for inbound cross-cluster
// connections.
Filters []types.Filter
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial DescribeInboundConnections operation returns a nextToken , you
// can include the returned nextToken in subsequent DescribeInboundConnections
// operations, which returns results in the next page.
NextToken *string
noSmithyDocumentSerde
}
// Contains a list of connections matching the filter criteria.
type DescribeInboundConnectionsOutput struct {
// List of inbound connections.
Connections []types.InboundConnection
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeInboundConnectionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeInboundConnections{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeInboundConnections{}, 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_opDescribeInboundConnections(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribeInboundConnectionsAPIClient is a client that implements the
// DescribeInboundConnections operation.
type DescribeInboundConnectionsAPIClient interface {
DescribeInboundConnections(context.Context, *DescribeInboundConnectionsInput, ...func(*Options)) (*DescribeInboundConnectionsOutput, error)
}
var _ DescribeInboundConnectionsAPIClient = (*Client)(nil)
// DescribeInboundConnectionsPaginatorOptions is the paginator options for
// DescribeInboundConnections
type DescribeInboundConnectionsPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeInboundConnectionsPaginator is a paginator for
// DescribeInboundConnections
type DescribeInboundConnectionsPaginator struct {
options DescribeInboundConnectionsPaginatorOptions
client DescribeInboundConnectionsAPIClient
params *DescribeInboundConnectionsInput
nextToken *string
firstPage bool
}
// NewDescribeInboundConnectionsPaginator returns a new
// DescribeInboundConnectionsPaginator
func NewDescribeInboundConnectionsPaginator(client DescribeInboundConnectionsAPIClient, params *DescribeInboundConnectionsInput, optFns ...func(*DescribeInboundConnectionsPaginatorOptions)) *DescribeInboundConnectionsPaginator {
if params == nil {
params = &DescribeInboundConnectionsInput{}
}
options := DescribeInboundConnectionsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeInboundConnectionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeInboundConnectionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeInboundConnections page.
func (p *DescribeInboundConnectionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeInboundConnectionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.DescribeInboundConnections(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeInboundConnections(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeInboundConnections",
}
}
| 231 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the instance count, storage, and master node limits for a given
// OpenSearch or Elasticsearch version and instance type.
func (c *Client) DescribeInstanceTypeLimits(ctx context.Context, params *DescribeInstanceTypeLimitsInput, optFns ...func(*Options)) (*DescribeInstanceTypeLimitsOutput, error) {
if params == nil {
params = &DescribeInstanceTypeLimitsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeInstanceTypeLimits", params, optFns, c.addOperationDescribeInstanceTypeLimitsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeInstanceTypeLimitsOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeInstanceTypeLimits operation.
type DescribeInstanceTypeLimitsInput struct {
// Version of OpenSearch or Elasticsearch, in the format Elasticsearch_X.Y or
// OpenSearch_X.Y. Defaults to the latest version of OpenSearch.
//
// This member is required.
EngineVersion *string
// The OpenSearch Service instance type for which you need limit information.
//
// This member is required.
InstanceType types.OpenSearchPartitionInstanceType
// The name of the domain. Only specify if you need the limits for an existing
// domain.
DomainName *string
noSmithyDocumentSerde
}
// Container for the parameters received from the DescribeInstanceTypeLimits
// operation.
type DescribeInstanceTypeLimitsOutput struct {
// Map that contains all applicable instance type limits. data refers to data
// nodes. master refers to dedicated master nodes.
LimitsByRole map[string]types.Limits
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeInstanceTypeLimitsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeInstanceTypeLimits{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeInstanceTypeLimits{}, 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 = addOpDescribeInstanceTypeLimitsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeInstanceTypeLimits(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeInstanceTypeLimits(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeInstanceTypeLimits",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all the outbound cross-cluster connections for a local (source) Amazon
// OpenSearch Service domain. For more information, see Cross-cluster search for
// Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/cross-cluster-search.html)
// .
func (c *Client) DescribeOutboundConnections(ctx context.Context, params *DescribeOutboundConnectionsInput, optFns ...func(*Options)) (*DescribeOutboundConnectionsOutput, error) {
if params == nil {
params = &DescribeOutboundConnectionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeOutboundConnections", params, optFns, c.addOperationDescribeOutboundConnectionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeOutboundConnectionsOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the DescribeOutboundConnections operation.
type DescribeOutboundConnectionsInput struct {
// List of filter names and values that you can use for requests.
Filters []types.Filter
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial DescribeOutboundConnections operation returns a nextToken , you
// can include the returned nextToken in subsequent DescribeOutboundConnections
// operations, which returns results in the next page.
NextToken *string
noSmithyDocumentSerde
}
// Contains a list of connections matching the filter criteria.
type DescribeOutboundConnectionsOutput struct {
// List of outbound connections that match the filter criteria.
Connections []types.OutboundConnection
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeOutboundConnectionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeOutboundConnections{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeOutboundConnections{}, 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_opDescribeOutboundConnections(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribeOutboundConnectionsAPIClient is a client that implements the
// DescribeOutboundConnections operation.
type DescribeOutboundConnectionsAPIClient interface {
DescribeOutboundConnections(context.Context, *DescribeOutboundConnectionsInput, ...func(*Options)) (*DescribeOutboundConnectionsOutput, error)
}
var _ DescribeOutboundConnectionsAPIClient = (*Client)(nil)
// DescribeOutboundConnectionsPaginatorOptions is the paginator options for
// DescribeOutboundConnections
type DescribeOutboundConnectionsPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeOutboundConnectionsPaginator is a paginator for
// DescribeOutboundConnections
type DescribeOutboundConnectionsPaginator struct {
options DescribeOutboundConnectionsPaginatorOptions
client DescribeOutboundConnectionsAPIClient
params *DescribeOutboundConnectionsInput
nextToken *string
firstPage bool
}
// NewDescribeOutboundConnectionsPaginator returns a new
// DescribeOutboundConnectionsPaginator
func NewDescribeOutboundConnectionsPaginator(client DescribeOutboundConnectionsAPIClient, params *DescribeOutboundConnectionsInput, optFns ...func(*DescribeOutboundConnectionsPaginatorOptions)) *DescribeOutboundConnectionsPaginator {
if params == nil {
params = &DescribeOutboundConnectionsInput{}
}
options := DescribeOutboundConnectionsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeOutboundConnectionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeOutboundConnectionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeOutboundConnections page.
func (p *DescribeOutboundConnectionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeOutboundConnectionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.DescribeOutboundConnections(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeOutboundConnections(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeOutboundConnections",
}
}
| 230 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes all packages available to OpenSearch Service. For more information,
// see Custom packages for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/custom-packages.html)
// .
func (c *Client) DescribePackages(ctx context.Context, params *DescribePackagesInput, optFns ...func(*Options)) (*DescribePackagesOutput, error) {
if params == nil {
params = &DescribePackagesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribePackages", params, optFns, c.addOperationDescribePackagesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribePackagesOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to the DescribePackage operation.
type DescribePackagesInput struct {
// Only returns packages that match the DescribePackagesFilterList values.
Filters []types.DescribePackagesFilter
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial DescribePackageFilters operation returns a nextToken , you can
// include the returned nextToken in subsequent DescribePackageFilters operations,
// which returns results in the next page.
NextToken *string
noSmithyDocumentSerde
}
// Container for the response returned by the DescribePackages operation.
type DescribePackagesOutput struct {
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// Basic information about a package.
PackageDetailsList []types.PackageDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribePackagesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribePackages{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribePackages{}, 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_opDescribePackages(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribePackagesAPIClient is a client that implements the DescribePackages
// operation.
type DescribePackagesAPIClient interface {
DescribePackages(context.Context, *DescribePackagesInput, ...func(*Options)) (*DescribePackagesOutput, error)
}
var _ DescribePackagesAPIClient = (*Client)(nil)
// DescribePackagesPaginatorOptions is the paginator options for DescribePackages
type DescribePackagesPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribePackagesPaginator is a paginator for DescribePackages
type DescribePackagesPaginator struct {
options DescribePackagesPaginatorOptions
client DescribePackagesAPIClient
params *DescribePackagesInput
nextToken *string
firstPage bool
}
// NewDescribePackagesPaginator returns a new DescribePackagesPaginator
func NewDescribePackagesPaginator(client DescribePackagesAPIClient, params *DescribePackagesInput, optFns ...func(*DescribePackagesPaginatorOptions)) *DescribePackagesPaginator {
if params == nil {
params = &DescribePackagesInput{}
}
options := DescribePackagesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribePackagesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribePackagesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribePackages page.
func (p *DescribePackagesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribePackagesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.DescribePackages(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribePackages(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribePackages",
}
}
| 226 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the available Amazon OpenSearch Service Reserved Instance offerings
// for a given Region. For more information, see Reserved Instances in Amazon
// OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/ri.html)
// .
func (c *Client) DescribeReservedInstanceOfferings(ctx context.Context, params *DescribeReservedInstanceOfferingsInput, optFns ...func(*Options)) (*DescribeReservedInstanceOfferingsOutput, error) {
if params == nil {
params = &DescribeReservedInstanceOfferingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeReservedInstanceOfferings", params, optFns, c.addOperationDescribeReservedInstanceOfferingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeReservedInstanceOfferingsOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to a DescribeReservedInstanceOfferings
// operation.
type DescribeReservedInstanceOfferingsInput struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial DescribeReservedInstanceOfferings operation returns a nextToken
// , you can include the returned nextToken in subsequent
// DescribeReservedInstanceOfferings operations, which returns results in the next
// page.
NextToken *string
// The Reserved Instance identifier filter value. Use this parameter to show only
// the available instance types that match the specified reservation identifier.
ReservedInstanceOfferingId *string
noSmithyDocumentSerde
}
// Container for results of a DescribeReservedInstanceOfferings request.
type DescribeReservedInstanceOfferingsOutput struct {
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// List of Reserved Instance offerings.
ReservedInstanceOfferings []types.ReservedInstanceOffering
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeReservedInstanceOfferingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeReservedInstanceOfferings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeReservedInstanceOfferings{}, 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_opDescribeReservedInstanceOfferings(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribeReservedInstanceOfferingsAPIClient is a client that implements the
// DescribeReservedInstanceOfferings operation.
type DescribeReservedInstanceOfferingsAPIClient interface {
DescribeReservedInstanceOfferings(context.Context, *DescribeReservedInstanceOfferingsInput, ...func(*Options)) (*DescribeReservedInstanceOfferingsOutput, error)
}
var _ DescribeReservedInstanceOfferingsAPIClient = (*Client)(nil)
// DescribeReservedInstanceOfferingsPaginatorOptions is the paginator options for
// DescribeReservedInstanceOfferings
type DescribeReservedInstanceOfferingsPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeReservedInstanceOfferingsPaginator is a paginator for
// DescribeReservedInstanceOfferings
type DescribeReservedInstanceOfferingsPaginator struct {
options DescribeReservedInstanceOfferingsPaginatorOptions
client DescribeReservedInstanceOfferingsAPIClient
params *DescribeReservedInstanceOfferingsInput
nextToken *string
firstPage bool
}
// NewDescribeReservedInstanceOfferingsPaginator returns a new
// DescribeReservedInstanceOfferingsPaginator
func NewDescribeReservedInstanceOfferingsPaginator(client DescribeReservedInstanceOfferingsAPIClient, params *DescribeReservedInstanceOfferingsInput, optFns ...func(*DescribeReservedInstanceOfferingsPaginatorOptions)) *DescribeReservedInstanceOfferingsPaginator {
if params == nil {
params = &DescribeReservedInstanceOfferingsInput{}
}
options := DescribeReservedInstanceOfferingsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeReservedInstanceOfferingsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeReservedInstanceOfferingsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeReservedInstanceOfferings page.
func (p *DescribeReservedInstanceOfferingsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeReservedInstanceOfferingsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.DescribeReservedInstanceOfferings(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeReservedInstanceOfferings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeReservedInstanceOfferings",
}
}
| 233 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the Amazon OpenSearch Service instances that you have reserved in a
// given Region. For more information, see Reserved Instances in Amazon OpenSearch
// Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/ri.html)
// .
func (c *Client) DescribeReservedInstances(ctx context.Context, params *DescribeReservedInstancesInput, optFns ...func(*Options)) (*DescribeReservedInstancesOutput, error) {
if params == nil {
params = &DescribeReservedInstancesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeReservedInstances", params, optFns, c.addOperationDescribeReservedInstancesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeReservedInstancesOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to the DescribeReservedInstances operation.
type DescribeReservedInstancesInput struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial DescribeReservedInstances operation returns a nextToken , you
// can include the returned nextToken in subsequent DescribeReservedInstances
// operations, which returns results in the next page.
NextToken *string
// The reserved instance identifier filter value. Use this parameter to show only
// the reservation that matches the specified reserved OpenSearch instance ID.
ReservedInstanceId *string
noSmithyDocumentSerde
}
// Container for results from DescribeReservedInstances
type DescribeReservedInstancesOutput struct {
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// List of Reserved Instances in the current Region.
ReservedInstances []types.ReservedInstance
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeReservedInstancesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeReservedInstances{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeReservedInstances{}, 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_opDescribeReservedInstances(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribeReservedInstancesAPIClient is a client that implements the
// DescribeReservedInstances operation.
type DescribeReservedInstancesAPIClient interface {
DescribeReservedInstances(context.Context, *DescribeReservedInstancesInput, ...func(*Options)) (*DescribeReservedInstancesOutput, error)
}
var _ DescribeReservedInstancesAPIClient = (*Client)(nil)
// DescribeReservedInstancesPaginatorOptions is the paginator options for
// DescribeReservedInstances
type DescribeReservedInstancesPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeReservedInstancesPaginator is a paginator for DescribeReservedInstances
type DescribeReservedInstancesPaginator struct {
options DescribeReservedInstancesPaginatorOptions
client DescribeReservedInstancesAPIClient
params *DescribeReservedInstancesInput
nextToken *string
firstPage bool
}
// NewDescribeReservedInstancesPaginator returns a new
// DescribeReservedInstancesPaginator
func NewDescribeReservedInstancesPaginator(client DescribeReservedInstancesAPIClient, params *DescribeReservedInstancesInput, optFns ...func(*DescribeReservedInstancesPaginatorOptions)) *DescribeReservedInstancesPaginator {
if params == nil {
params = &DescribeReservedInstancesInput{}
}
options := DescribeReservedInstancesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeReservedInstancesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeReservedInstancesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeReservedInstances page.
func (p *DescribeReservedInstancesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeReservedInstancesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.DescribeReservedInstances(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opDescribeReservedInstances(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeReservedInstances",
}
}
| 230 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes one or more Amazon OpenSearch Service-managed VPC endpoints.
func (c *Client) DescribeVpcEndpoints(ctx context.Context, params *DescribeVpcEndpointsInput, optFns ...func(*Options)) (*DescribeVpcEndpointsOutput, error) {
if params == nil {
params = &DescribeVpcEndpointsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeVpcEndpoints", params, optFns, c.addOperationDescribeVpcEndpointsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeVpcEndpointsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeVpcEndpointsInput struct {
// The unique identifiers of the endpoints to get information about.
//
// This member is required.
VpcEndpointIds []string
noSmithyDocumentSerde
}
type DescribeVpcEndpointsOutput struct {
// Any errors associated with the request.
//
// This member is required.
VpcEndpointErrors []types.VpcEndpointError
// Information about each requested VPC endpoint.
//
// This member is required.
VpcEndpoints []types.VpcEndpoint
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeVpcEndpointsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeVpcEndpoints{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeVpcEndpoints{}, 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 = addOpDescribeVpcEndpointsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeVpcEndpoints(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeVpcEndpoints(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DescribeVpcEndpoints",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes a package from the specified Amazon OpenSearch Service domain. The
// package can't be in use with any OpenSearch index for the dissociation to
// succeed. The package is still available in OpenSearch Service for association
// later. For more information, see Custom packages for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/custom-packages.html)
// .
func (c *Client) DissociatePackage(ctx context.Context, params *DissociatePackageInput, optFns ...func(*Options)) (*DissociatePackageOutput, error) {
if params == nil {
params = &DissociatePackageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DissociatePackage", params, optFns, c.addOperationDissociatePackageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DissociatePackageOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to the DissociatePackage operation.
type DissociatePackageInput struct {
// Name of the domain to dissociate the package from.
//
// This member is required.
DomainName *string
// Internal ID of the package to dissociate from the domain. Use
// ListPackagesForDomain to find this value.
//
// This member is required.
PackageID *string
noSmithyDocumentSerde
}
// Container for the response returned by an DissociatePackage operation.
type DissociatePackageOutput struct {
// Information about a package that has been dissociated from the domain.
DomainPackageDetails *types.DomainPackageDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDissociatePackageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDissociatePackage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDissociatePackage{}, 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 = addOpDissociatePackageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDissociatePackage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDissociatePackage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "DissociatePackage",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a map of OpenSearch or Elasticsearch versions and the versions you can
// upgrade them to.
func (c *Client) GetCompatibleVersions(ctx context.Context, params *GetCompatibleVersionsInput, optFns ...func(*Options)) (*GetCompatibleVersionsOutput, error) {
if params == nil {
params = &GetCompatibleVersionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetCompatibleVersions", params, optFns, c.addOperationGetCompatibleVersionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetCompatibleVersionsOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to GetCompatibleVersions operation.
type GetCompatibleVersionsInput struct {
// The name of an existing domain. Provide this parameter to limit the results to
// a single domain.
DomainName *string
noSmithyDocumentSerde
}
// Container for the response returned by the GetCompatibleVersions operation.
type GetCompatibleVersionsOutput struct {
// A map of OpenSearch or Elasticsearch versions and the versions you can upgrade
// them to.
CompatibleVersions []types.CompatibleVersionsMap
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetCompatibleVersionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetCompatibleVersions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetCompatibleVersions{}, 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_opGetCompatibleVersions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetCompatibleVersions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "GetCompatibleVersions",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of Amazon OpenSearch Service package versions, along with their
// creation time, commit message, and plugin properties (if the package is a zip
// plugin package). For more information, see Custom packages for Amazon
// OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/custom-packages.html)
// .
func (c *Client) GetPackageVersionHistory(ctx context.Context, params *GetPackageVersionHistoryInput, optFns ...func(*Options)) (*GetPackageVersionHistoryOutput, error) {
if params == nil {
params = &GetPackageVersionHistoryInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetPackageVersionHistory", params, optFns, c.addOperationGetPackageVersionHistoryMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetPackageVersionHistoryOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to the GetPackageVersionHistory operation.
type GetPackageVersionHistoryInput struct {
// The unique identifier of the package.
//
// This member is required.
PackageID *string
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial GetPackageVersionHistory operation returns a nextToken , you can
// include the returned nextToken in subsequent GetPackageVersionHistory
// operations, which returns results in the next page.
NextToken *string
noSmithyDocumentSerde
}
// Container for response returned by GetPackageVersionHistory operation.
type GetPackageVersionHistoryOutput struct {
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// The unique identifier of the package.
PackageID *string
// A list of package versions, along with their creation time and commit message.
PackageVersionHistoryList []types.PackageVersionHistory
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetPackageVersionHistoryMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetPackageVersionHistory{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetPackageVersionHistory{}, 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 = addOpGetPackageVersionHistoryValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetPackageVersionHistory(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// GetPackageVersionHistoryAPIClient is a client that implements the
// GetPackageVersionHistory operation.
type GetPackageVersionHistoryAPIClient interface {
GetPackageVersionHistory(context.Context, *GetPackageVersionHistoryInput, ...func(*Options)) (*GetPackageVersionHistoryOutput, error)
}
var _ GetPackageVersionHistoryAPIClient = (*Client)(nil)
// GetPackageVersionHistoryPaginatorOptions is the paginator options for
// GetPackageVersionHistory
type GetPackageVersionHistoryPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// GetPackageVersionHistoryPaginator is a paginator for GetPackageVersionHistory
type GetPackageVersionHistoryPaginator struct {
options GetPackageVersionHistoryPaginatorOptions
client GetPackageVersionHistoryAPIClient
params *GetPackageVersionHistoryInput
nextToken *string
firstPage bool
}
// NewGetPackageVersionHistoryPaginator returns a new
// GetPackageVersionHistoryPaginator
func NewGetPackageVersionHistoryPaginator(client GetPackageVersionHistoryAPIClient, params *GetPackageVersionHistoryInput, optFns ...func(*GetPackageVersionHistoryPaginatorOptions)) *GetPackageVersionHistoryPaginator {
if params == nil {
params = &GetPackageVersionHistoryInput{}
}
options := GetPackageVersionHistoryPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetPackageVersionHistoryPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetPackageVersionHistoryPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetPackageVersionHistory page.
func (p *GetPackageVersionHistoryPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetPackageVersionHistoryOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.GetPackageVersionHistory(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opGetPackageVersionHistory(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "GetPackageVersionHistory",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the complete history of the last 10 upgrades performed on an Amazon
// OpenSearch Service domain.
func (c *Client) GetUpgradeHistory(ctx context.Context, params *GetUpgradeHistoryInput, optFns ...func(*Options)) (*GetUpgradeHistoryOutput, error) {
if params == nil {
params = &GetUpgradeHistoryInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetUpgradeHistory", params, optFns, c.addOperationGetUpgradeHistoryMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetUpgradeHistoryOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to the GetUpgradeHistory operation.
type GetUpgradeHistoryInput struct {
// The name of an existing domain.
//
// This member is required.
DomainName *string
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial GetUpgradeHistory operation returns a nextToken , you can
// include the returned nextToken in subsequent GetUpgradeHistory operations,
// which returns results in the next page.
NextToken *string
noSmithyDocumentSerde
}
// Container for the response returned by the GetUpgradeHistory operation.
type GetUpgradeHistoryOutput struct {
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// A list of objects corresponding to each upgrade or upgrade eligibility check
// performed on a domain.
UpgradeHistories []types.UpgradeHistory
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetUpgradeHistoryMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetUpgradeHistory{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetUpgradeHistory{}, 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 = addOpGetUpgradeHistoryValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetUpgradeHistory(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// GetUpgradeHistoryAPIClient is a client that implements the GetUpgradeHistory
// operation.
type GetUpgradeHistoryAPIClient interface {
GetUpgradeHistory(context.Context, *GetUpgradeHistoryInput, ...func(*Options)) (*GetUpgradeHistoryOutput, error)
}
var _ GetUpgradeHistoryAPIClient = (*Client)(nil)
// GetUpgradeHistoryPaginatorOptions is the paginator options for GetUpgradeHistory
type GetUpgradeHistoryPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// GetUpgradeHistoryPaginator is a paginator for GetUpgradeHistory
type GetUpgradeHistoryPaginator struct {
options GetUpgradeHistoryPaginatorOptions
client GetUpgradeHistoryAPIClient
params *GetUpgradeHistoryInput
nextToken *string
firstPage bool
}
// NewGetUpgradeHistoryPaginator returns a new GetUpgradeHistoryPaginator
func NewGetUpgradeHistoryPaginator(client GetUpgradeHistoryAPIClient, params *GetUpgradeHistoryInput, optFns ...func(*GetUpgradeHistoryPaginatorOptions)) *GetUpgradeHistoryPaginator {
if params == nil {
params = &GetUpgradeHistoryInput{}
}
options := GetUpgradeHistoryPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetUpgradeHistoryPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetUpgradeHistoryPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetUpgradeHistory page.
func (p *GetUpgradeHistoryPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetUpgradeHistoryOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.GetUpgradeHistory(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opGetUpgradeHistory(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "GetUpgradeHistory",
}
}
| 231 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the most recent status of the last upgrade or upgrade eligibility check
// performed on an Amazon OpenSearch Service domain.
func (c *Client) GetUpgradeStatus(ctx context.Context, params *GetUpgradeStatusInput, optFns ...func(*Options)) (*GetUpgradeStatusOutput, error) {
if params == nil {
params = &GetUpgradeStatusInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetUpgradeStatus", params, optFns, c.addOperationGetUpgradeStatusMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetUpgradeStatusOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to the GetUpgradeStatus operation.
type GetUpgradeStatusInput struct {
// The domain of the domain to get upgrade status information for.
//
// This member is required.
DomainName *string
noSmithyDocumentSerde
}
// Container for the response returned by the GetUpgradeStatus operation.
type GetUpgradeStatusOutput struct {
// The status of the current step that an upgrade is on.
StepStatus types.UpgradeStatus
// A string that describes the update.
UpgradeName *string
// One of three steps that an upgrade or upgrade eligibility check goes through.
UpgradeStep types.UpgradeStep
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetUpgradeStatusMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetUpgradeStatus{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetUpgradeStatus{}, 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 = addOpGetUpgradeStatusValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetUpgradeStatus(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetUpgradeStatus(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "GetUpgradeStatus",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the names of all Amazon OpenSearch Service domains owned by the current
// user in the active Region.
func (c *Client) ListDomainNames(ctx context.Context, params *ListDomainNamesInput, optFns ...func(*Options)) (*ListDomainNamesOutput, error) {
if params == nil {
params = &ListDomainNamesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDomainNames", params, optFns, c.addOperationListDomainNamesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDomainNamesOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the parameters to the ListDomainNames operation.
type ListDomainNamesInput struct {
// Filters the output by domain engine type.
EngineType types.EngineType
noSmithyDocumentSerde
}
// The results of a ListDomainNames operation. Contains the names of all domains
// owned by this account and their respective engine types.
type ListDomainNamesOutput struct {
// The names of all OpenSearch Service domains owned by the current user and their
// respective engine types.
DomainNames []types.DomainInfo
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDomainNamesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDomainNames{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDomainNames{}, 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_opListDomainNames(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opListDomainNames(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "ListDomainNames",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all Amazon OpenSearch Service domains associated with a given package.
// For more information, see Custom packages for Amazon OpenSearch Service (https://docs.aws.amazon.com/opensearch-service/latest/developerguide/custom-packages.html)
// .
func (c *Client) ListDomainsForPackage(ctx context.Context, params *ListDomainsForPackageInput, optFns ...func(*Options)) (*ListDomainsForPackageOutput, error) {
if params == nil {
params = &ListDomainsForPackageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDomainsForPackage", params, optFns, c.addOperationListDomainsForPackageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDomainsForPackageOutput)
out.ResultMetadata = metadata
return out, nil
}
// Container for the request parameters to the ListDomainsForPackage operation.
type ListDomainsForPackageInput struct {
// The unique identifier of the package for which to list associated domains.
//
// This member is required.
PackageID *string
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial ListDomainsForPackage operation returns a nextToken , you can
// include the returned nextToken in subsequent ListDomainsForPackage operations,
// which returns results in the next page.
NextToken *string
noSmithyDocumentSerde
}
// Container for the response parameters to the ListDomainsForPackage operation.
type ListDomainsForPackageOutput struct {
// Information about all domains associated with a package.
DomainPackageDetailsList []types.DomainPackageDetails
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDomainsForPackageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDomainsForPackage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDomainsForPackage{}, 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 = addOpListDomainsForPackageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDomainsForPackage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDomainsForPackageAPIClient is a client that implements the
// ListDomainsForPackage operation.
type ListDomainsForPackageAPIClient interface {
ListDomainsForPackage(context.Context, *ListDomainsForPackageInput, ...func(*Options)) (*ListDomainsForPackageOutput, error)
}
var _ ListDomainsForPackageAPIClient = (*Client)(nil)
// ListDomainsForPackagePaginatorOptions is the paginator options for
// ListDomainsForPackage
type ListDomainsForPackagePaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListDomainsForPackagePaginator is a paginator for ListDomainsForPackage
type ListDomainsForPackagePaginator struct {
options ListDomainsForPackagePaginatorOptions
client ListDomainsForPackageAPIClient
params *ListDomainsForPackageInput
nextToken *string
firstPage bool
}
// NewListDomainsForPackagePaginator returns a new ListDomainsForPackagePaginator
func NewListDomainsForPackagePaginator(client ListDomainsForPackageAPIClient, params *ListDomainsForPackageInput, optFns ...func(*ListDomainsForPackagePaginatorOptions)) *ListDomainsForPackagePaginator {
if params == nil {
params = &ListDomainsForPackageInput{}
}
options := ListDomainsForPackagePaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDomainsForPackagePaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDomainsForPackagePaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDomainsForPackage page.
func (p *ListDomainsForPackagePaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDomainsForPackageOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListDomainsForPackage(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDomainsForPackage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "ListDomainsForPackage",
}
}
| 232 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package opensearch
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/opensearch/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all instance types and available features for a given OpenSearch or
// Elasticsearch version.
func (c *Client) ListInstanceTypeDetails(ctx context.Context, params *ListInstanceTypeDetailsInput, optFns ...func(*Options)) (*ListInstanceTypeDetailsOutput, error) {
if params == nil {
params = &ListInstanceTypeDetailsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListInstanceTypeDetails", params, optFns, c.addOperationListInstanceTypeDetailsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListInstanceTypeDetailsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListInstanceTypeDetailsInput struct {
// The version of OpenSearch or Elasticsearch, in the format Elasticsearch_X.Y or
// OpenSearch_X.Y. Defaults to the latest version of OpenSearch.
//
// This member is required.
EngineVersion *string
// The name of the domain.
DomainName *string
// An optional parameter that lists information for a given instance type.
InstanceType *string
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
MaxResults int32
// If your initial ListInstanceTypeDetails operation returns a nextToken , you can
// include the returned nextToken in subsequent ListInstanceTypeDetails
// operations, which returns results in the next page.
NextToken *string
// An optional parameter that specifies the Availability Zones for the domain.
RetrieveAZs *bool
noSmithyDocumentSerde
}
type ListInstanceTypeDetailsOutput struct {
// Lists all supported instance types and features for the given OpenSearch or
// Elasticsearch version.
InstanceTypeDetails []types.InstanceTypeDetails
// When nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListInstanceTypeDetailsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListInstanceTypeDetails{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListInstanceTypeDetails{}, 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 = addOpListInstanceTypeDetailsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListInstanceTypeDetails(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListInstanceTypeDetailsAPIClient is a client that implements the
// ListInstanceTypeDetails operation.
type ListInstanceTypeDetailsAPIClient interface {
ListInstanceTypeDetails(context.Context, *ListInstanceTypeDetailsInput, ...func(*Options)) (*ListInstanceTypeDetailsOutput, error)
}
var _ ListInstanceTypeDetailsAPIClient = (*Client)(nil)
// ListInstanceTypeDetailsPaginatorOptions is the paginator options for
// ListInstanceTypeDetails
type ListInstanceTypeDetailsPaginatorOptions struct {
// An optional parameter that specifies the maximum number of results to return.
// You can use nextToken to get the next page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListInstanceTypeDetailsPaginator is a paginator for ListInstanceTypeDetails
type ListInstanceTypeDetailsPaginator struct {
options ListInstanceTypeDetailsPaginatorOptions
client ListInstanceTypeDetailsAPIClient
params *ListInstanceTypeDetailsInput
nextToken *string
firstPage bool
}
// NewListInstanceTypeDetailsPaginator returns a new
// ListInstanceTypeDetailsPaginator
func NewListInstanceTypeDetailsPaginator(client ListInstanceTypeDetailsAPIClient, params *ListInstanceTypeDetailsInput, optFns ...func(*ListInstanceTypeDetailsPaginatorOptions)) *ListInstanceTypeDetailsPaginator {
if params == nil {
params = &ListInstanceTypeDetailsInput{}
}
options := ListInstanceTypeDetailsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListInstanceTypeDetailsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListInstanceTypeDetailsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListInstanceTypeDetails page.
func (p *ListInstanceTypeDetailsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListInstanceTypeDetailsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListInstanceTypeDetails(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListInstanceTypeDetails(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "es",
OperationName: "ListInstanceTypeDetails",
}
}
| 241 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.