memcached

Documentation

Index

• Constants
• type Memcached
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Memcached
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Memcached
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Memcached
  • func (c *Memcached) CreateCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) CreateCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) CreateCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) DeleteCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) DeleteCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) DeleteCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) DeleteCacheSecurityRule(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) DeleteCacheSecurityRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) DeleteCacheSecurityRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeAvailabilityZones(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeAvailabilityZonesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) DescribeAvailabilityZonesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) DescribeCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeCacheClusters(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeCacheClustersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) DescribeCacheClustersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeCacheSecurityRules(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeCacheSecurityRulesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) DescribeCacheSecurityRulesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeRegions(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) DescribeRegionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) DescribeRegionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) FlushCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) FlushCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) FlushCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) RenameCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) RenameCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) RenameCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) ResizeCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) ResizeCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) ResizeCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) SetCacheSecurityRules(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) SetCacheSecurityRulesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) SetCacheSecurityRulesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Memcached) UpdatePassword(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Memcached) UpdatePasswordRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Memcached) UpdatePasswordWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

const (
	ServiceName = "memcached" // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "memcached" // ServiceID is a unique identifer of a specific service.
)

Service information constants

Types

type Memcached

type Memcached struct {
	*client.Client
}

Memcached provides the API operation methods for making requests to memcached. See this package's package overview docs for details on the service.

Memcached methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Memcached

extraNew create int can support ssl or region locate set

func New

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Memcached

New creates a new instance of the Memcached client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Memcached client from just a session.
svc := memcached.New(mySession)

// Create a Memcached client with additional configuration
svc := memcached.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Memcached

SdkNew create int can support ssl or region locate set

func (*Memcached) CreateCacheCluster

func (c *Memcached) CreateCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

CreateCacheCluster API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation CreateCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/CreateCacheCluster

func (*Memcached) CreateCacheClusterRequest

func (c *Memcached) CreateCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the CreateCacheCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateCacheCluster for more information on using the CreateCacheCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateCacheClusterRequest method.
req, resp := client.CreateCacheClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/CreateCacheCluster

func (*Memcached) CreateCacheClusterWithContext

func (c *Memcached) CreateCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateCacheClusterWithContext is the same as CreateCacheCluster with the addition of the ability to pass a context and additional request options.

See CreateCacheCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) DeleteCacheCluster

func (c *Memcached) DeleteCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCacheCluster API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation DeleteCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DeleteCacheCluster

func (*Memcached) DeleteCacheClusterRequest

func (c *Memcached) DeleteCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the DeleteCacheCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteCacheCluster for more information on using the DeleteCacheCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteCacheClusterRequest method.
req, resp := client.DeleteCacheClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DeleteCacheCluster

func (*Memcached) DeleteCacheClusterWithContext

func (c *Memcached) DeleteCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteCacheClusterWithContext is the same as DeleteCacheCluster with the addition of the ability to pass a context and additional request options.

See DeleteCacheCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) DeleteCacheSecurityRule

func (c *Memcached) DeleteCacheSecurityRule(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteCacheSecurityRule API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation DeleteCacheSecurityRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DeleteCacheSecurityRule

func (*Memcached) DeleteCacheSecurityRuleRequest

func (c *Memcached) DeleteCacheSecurityRuleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteCacheSecurityRuleRequest generates a "ksc/request.Request" representing the client's request for the DeleteCacheSecurityRule operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteCacheSecurityRule for more information on using the DeleteCacheSecurityRule API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteCacheSecurityRuleRequest method.
req, resp := client.DeleteCacheSecurityRuleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DeleteCacheSecurityRule

func (*Memcached) DeleteCacheSecurityRuleWithContext

func (c *Memcached) DeleteCacheSecurityRuleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteCacheSecurityRuleWithContext is the same as DeleteCacheSecurityRule with the addition of the ability to pass a context and additional request options.

See DeleteCacheSecurityRule for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) DescribeAvailabilityZones

func (c *Memcached) DescribeAvailabilityZones(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeAvailabilityZones API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation DescribeAvailabilityZones for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeAvailabilityZones

func (*Memcached) DescribeAvailabilityZonesRequest

func (c *Memcached) DescribeAvailabilityZonesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeAvailabilityZonesRequest generates a "ksc/request.Request" representing the client's request for the DescribeAvailabilityZones operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeAvailabilityZones for more information on using the DescribeAvailabilityZones API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeAvailabilityZonesRequest method.
req, resp := client.DescribeAvailabilityZonesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeAvailabilityZones

func (*Memcached) DescribeAvailabilityZonesWithContext

func (c *Memcached) DescribeAvailabilityZonesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeAvailabilityZonesWithContext is the same as DescribeAvailabilityZones with the addition of the ability to pass a context and additional request options.

See DescribeAvailabilityZones for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) DescribeCacheCluster

func (c *Memcached) DescribeCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheCluster API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation DescribeCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeCacheCluster

func (*Memcached) DescribeCacheClusterRequest

func (c *Memcached) DescribeCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeCacheCluster for more information on using the DescribeCacheCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeCacheClusterRequest method.
req, resp := client.DescribeCacheClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeCacheCluster

func (*Memcached) DescribeCacheClusterWithContext

func (c *Memcached) DescribeCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeCacheClusterWithContext is the same as DescribeCacheCluster with the addition of the ability to pass a context and additional request options.

See DescribeCacheCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) DescribeCacheClusters

func (c *Memcached) DescribeCacheClusters(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheClusters API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation DescribeCacheClusters for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeCacheClusters

func (*Memcached) DescribeCacheClustersRequest

func (c *Memcached) DescribeCacheClustersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeCacheClustersRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheClusters operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeCacheClusters for more information on using the DescribeCacheClusters API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeCacheClustersRequest method.
req, resp := client.DescribeCacheClustersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeCacheClusters

func (*Memcached) DescribeCacheClustersWithContext

func (c *Memcached) DescribeCacheClustersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeCacheClustersWithContext is the same as DescribeCacheClusters with the addition of the ability to pass a context and additional request options.

See DescribeCacheClusters for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) DescribeCacheSecurityRules

func (c *Memcached) DescribeCacheSecurityRules(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeCacheSecurityRules API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation DescribeCacheSecurityRules for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeCacheSecurityRules

func (*Memcached) DescribeCacheSecurityRulesRequest

func (c *Memcached) DescribeCacheSecurityRulesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeCacheSecurityRulesRequest generates a "ksc/request.Request" representing the client's request for the DescribeCacheSecurityRules operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeCacheSecurityRules for more information on using the DescribeCacheSecurityRules API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeCacheSecurityRulesRequest method.
req, resp := client.DescribeCacheSecurityRulesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeCacheSecurityRules

func (*Memcached) DescribeCacheSecurityRulesWithContext

func (c *Memcached) DescribeCacheSecurityRulesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeCacheSecurityRulesWithContext is the same as DescribeCacheSecurityRules with the addition of the ability to pass a context and additional request options.

See DescribeCacheSecurityRules for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) DescribeRegions

func (c *Memcached) DescribeRegions(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeRegions API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation DescribeRegions for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeRegions

func (*Memcached) DescribeRegionsRequest

func (c *Memcached) DescribeRegionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeRegionsRequest generates a "ksc/request.Request" representing the client's request for the DescribeRegions operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeRegions for more information on using the DescribeRegions API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeRegionsRequest method.
req, resp := client.DescribeRegionsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/DescribeRegions

func (*Memcached) DescribeRegionsWithContext

func (c *Memcached) DescribeRegionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeRegionsWithContext is the same as DescribeRegions with the addition of the ability to pass a context and additional request options.

See DescribeRegions for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) FlushCacheCluster

func (c *Memcached) FlushCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

FlushCacheCluster API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation FlushCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/FlushCacheCluster

func (*Memcached) FlushCacheClusterRequest

func (c *Memcached) FlushCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

FlushCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the FlushCacheCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See FlushCacheCluster for more information on using the FlushCacheCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the FlushCacheClusterRequest method.
req, resp := client.FlushCacheClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/FlushCacheCluster

func (*Memcached) FlushCacheClusterWithContext

func (c *Memcached) FlushCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

FlushCacheClusterWithContext is the same as FlushCacheCluster with the addition of the ability to pass a context and additional request options.

See FlushCacheCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) RenameCacheCluster

func (c *Memcached) RenameCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

RenameCacheCluster API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation RenameCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/RenameCacheCluster

func (*Memcached) RenameCacheClusterRequest

func (c *Memcached) RenameCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RenameCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the RenameCacheCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RenameCacheCluster for more information on using the RenameCacheCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RenameCacheClusterRequest method.
req, resp := client.RenameCacheClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/RenameCacheCluster

func (*Memcached) RenameCacheClusterWithContext

func (c *Memcached) RenameCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RenameCacheClusterWithContext is the same as RenameCacheCluster with the addition of the ability to pass a context and additional request options.

See RenameCacheCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) ResizeCacheCluster

func (c *Memcached) ResizeCacheCluster(input *map[string]interface{}) (*map[string]interface{}, error)

ResizeCacheCluster API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation ResizeCacheCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/ResizeCacheCluster

func (*Memcached) ResizeCacheClusterRequest

func (c *Memcached) ResizeCacheClusterRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ResizeCacheClusterRequest generates a "ksc/request.Request" representing the client's request for the ResizeCacheCluster operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ResizeCacheCluster for more information on using the ResizeCacheCluster API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ResizeCacheClusterRequest method.
req, resp := client.ResizeCacheClusterRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/ResizeCacheCluster

func (*Memcached) ResizeCacheClusterWithContext

func (c *Memcached) ResizeCacheClusterWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ResizeCacheClusterWithContext is the same as ResizeCacheCluster with the addition of the ability to pass a context and additional request options.

See ResizeCacheCluster for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) SetCacheSecurityRules

func (c *Memcached) SetCacheSecurityRules(input *map[string]interface{}) (*map[string]interface{}, error)

SetCacheSecurityRules API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation SetCacheSecurityRules for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/SetCacheSecurityRules

func (*Memcached) SetCacheSecurityRulesRequest

func (c *Memcached) SetCacheSecurityRulesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetCacheSecurityRulesRequest generates a "ksc/request.Request" representing the client's request for the SetCacheSecurityRules operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetCacheSecurityRules for more information on using the SetCacheSecurityRules API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetCacheSecurityRulesRequest method.
req, resp := client.SetCacheSecurityRulesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/SetCacheSecurityRules

func (*Memcached) SetCacheSecurityRulesWithContext

func (c *Memcached) SetCacheSecurityRulesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetCacheSecurityRulesWithContext is the same as SetCacheSecurityRules with the addition of the ability to pass a context and additional request options.

See SetCacheSecurityRules for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Memcached) UpdatePassword

func (c *Memcached) UpdatePassword(input *map[string]interface{}) (*map[string]interface{}, error)

UpdatePassword API operation for memcached.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for memcached's API operation UpdatePassword for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/UpdatePassword

func (*Memcached) UpdatePasswordRequest

func (c *Memcached) UpdatePasswordRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdatePasswordRequest generates a "ksc/request.Request" representing the client's request for the UpdatePassword operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdatePassword for more information on using the UpdatePassword API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdatePasswordRequest method.
req, resp := client.UpdatePasswordRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/memcached-2018-06-27/UpdatePassword

func (*Memcached) UpdatePasswordWithContext

func (c *Memcached) UpdatePasswordWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdatePasswordWithContext is the same as UpdatePassword with the addition of the ability to pass a context and additional request options.

See UpdatePassword for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.