rabbitmq

package

v0.3.1 Latest Latest Go to latest Published: Jan 11, 2024 License: Apache-2.0, Apache-2.0 Imports: 9 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/baoyxing/ksc-sdk-go

Links

Open Source Insights

Documentation ¶

Constants ¶

View Source

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

Service information constants

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Rabbitmq ¶

type Rabbitmq struct {
	*client.Client
}

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

Rabbitmq 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) *Rabbitmq

extraNew create int can support ssl or region locate set

func New ¶

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

New creates a new instance of the Rabbitmq 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 Rabbitmq client from just a session.
svc := rabbitmq.New(mySession)

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

func SdkNew ¶

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

SdkNew create int can support ssl or region locate set

func (*Rabbitmq) AddSecurityGroupRule ¶

func (c *Rabbitmq) AddSecurityGroupRule(input *map[string]interface{}) (*map[string]interface{}, error)

AddSecurityGroupRule API operation for rabbitmq.

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 rabbitmq's API operation AddSecurityGroupRule for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/AddSecurityGroupRule

func (*Rabbitmq) AddSecurityGroupRuleRequest ¶

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

AddSecurityGroupRuleRequest generates a "ksc/request.Request" representing the client's request for the AddSecurityGroupRule 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 AddSecurityGroupRule for more information on using the AddSecurityGroupRule 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 AddSecurityGroupRuleRequest method.
req, resp := client.AddSecurityGroupRuleRequest(params)

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

func (*Rabbitmq) AddSecurityGroupRuleWithContext ¶

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

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

See AddSecurityGroupRule 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 (*Rabbitmq) AllocateEip ¶

func (c *Rabbitmq) AllocateEip(input *map[string]interface{}) (*map[string]interface{}, error)

AllocateEip API operation for rabbitmq.

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 rabbitmq's API operation AllocateEip for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/AllocateEip

func (*Rabbitmq) AllocateEipRequest ¶

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

AllocateEipRequest generates a "ksc/request.Request" representing the client's request for the AllocateEip 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 AllocateEip for more information on using the AllocateEip 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 AllocateEipRequest method.
req, resp := client.AllocateEipRequest(params)

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

func (*Rabbitmq) AllocateEipWithContext ¶

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

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

See AllocateEip 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 (*Rabbitmq) CheckInstanceConfig ¶

func (c *Rabbitmq) CheckInstanceConfig(input *map[string]interface{}) (*map[string]interface{}, error)

CheckInstanceConfig API operation for rabbitmq.

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 rabbitmq's API operation CheckInstanceConfig for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/CheckInstanceConfig

func (*Rabbitmq) CheckInstanceConfigRequest ¶

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

CheckInstanceConfigRequest generates a "ksc/request.Request" representing the client's request for the CheckInstanceConfig 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 CheckInstanceConfig for more information on using the CheckInstanceConfig 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 CheckInstanceConfigRequest method.
req, resp := client.CheckInstanceConfigRequest(params)

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

func (*Rabbitmq) CheckInstanceConfigWithContext ¶

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

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

See CheckInstanceConfig 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 (*Rabbitmq) CheckInstanceStatus ¶

func (c *Rabbitmq) CheckInstanceStatus(input *map[string]interface{}) (*map[string]interface{}, error)

CheckInstanceStatus API operation for rabbitmq.

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 rabbitmq's API operation CheckInstanceStatus for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/CheckInstanceStatus

func (*Rabbitmq) CheckInstanceStatusRequest ¶

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

CheckInstanceStatusRequest generates a "ksc/request.Request" representing the client's request for the CheckInstanceStatus 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 CheckInstanceStatus for more information on using the CheckInstanceStatus 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 CheckInstanceStatusRequest method.
req, resp := client.CheckInstanceStatusRequest(params)

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

func (*Rabbitmq) CheckInstanceStatusWithContext ¶

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

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

See CheckInstanceStatus 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 (*Rabbitmq) CreateInstance ¶

func (c *Rabbitmq) CreateInstance(input *map[string]interface{}) (*map[string]interface{}, error)

CreateInstance API operation for rabbitmq.

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 rabbitmq's API operation CreateInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/CreateInstance

func (*Rabbitmq) CreateInstanceRequest ¶

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

CreateInstanceRequest generates a "ksc/request.Request" representing the client's request for the CreateInstance 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 CreateInstance for more information on using the CreateInstance 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 CreateInstanceRequest method.
req, resp := client.CreateInstanceRequest(params)

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

func (*Rabbitmq) CreateInstanceWithContext ¶

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

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

See CreateInstance 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 (*Rabbitmq) DeallocateEip ¶

func (c *Rabbitmq) DeallocateEip(input *map[string]interface{}) (*map[string]interface{}, error)

DeallocateEip API operation for rabbitmq.

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 rabbitmq's API operation DeallocateEip for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DeallocateEip

func (*Rabbitmq) DeallocateEipRequest ¶

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

DeallocateEipRequest generates a "ksc/request.Request" representing the client's request for the DeallocateEip 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 DeallocateEip for more information on using the DeallocateEip 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 DeallocateEipRequest method.
req, resp := client.DeallocateEipRequest(params)

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

func (*Rabbitmq) DeallocateEipWithContext ¶

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

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

See DeallocateEip 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 (*Rabbitmq) DeleteInstance ¶

func (c *Rabbitmq) DeleteInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteInstance API operation for rabbitmq.

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 rabbitmq's API operation DeleteInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DeleteInstance

func (*Rabbitmq) DeleteInstanceRequest ¶

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

DeleteInstanceRequest generates a "ksc/request.Request" representing the client's request for the DeleteInstance 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 DeleteInstance for more information on using the DeleteInstance 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 DeleteInstanceRequest method.
req, resp := client.DeleteInstanceRequest(params)

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

func (*Rabbitmq) DeleteInstanceWithContext ¶

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

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

See DeleteInstance 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 (*Rabbitmq) DeleteSecurityGroupRules ¶

func (c *Rabbitmq) DeleteSecurityGroupRules(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteSecurityGroupRules API operation for rabbitmq.

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 rabbitmq's API operation DeleteSecurityGroupRules for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DeleteSecurityGroupRules

func (*Rabbitmq) DeleteSecurityGroupRulesRequest ¶

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

DeleteSecurityGroupRulesRequest generates a "ksc/request.Request" representing the client's request for the DeleteSecurityGroupRules 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 DeleteSecurityGroupRules for more information on using the DeleteSecurityGroupRules 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 DeleteSecurityGroupRulesRequest method.
req, resp := client.DeleteSecurityGroupRulesRequest(params)

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

func (*Rabbitmq) DeleteSecurityGroupRulesWithContext ¶

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

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

See DeleteSecurityGroupRules 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 (*Rabbitmq) DescribeInstance ¶

func (c *Rabbitmq) DescribeInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstance API operation for rabbitmq.

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 rabbitmq's API operation DescribeInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DescribeInstance

func (*Rabbitmq) DescribeInstanceNodes ¶

func (c *Rabbitmq) DescribeInstanceNodes(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceNodes API operation for rabbitmq.

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 rabbitmq's API operation DescribeInstanceNodes for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DescribeInstanceNodes

func (*Rabbitmq) DescribeInstanceNodesRequest ¶

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

DescribeInstanceNodesRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstanceNodes 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 DescribeInstanceNodes for more information on using the DescribeInstanceNodes 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 DescribeInstanceNodesRequest method.
req, resp := client.DescribeInstanceNodesRequest(params)

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

func (*Rabbitmq) DescribeInstanceNodesWithContext ¶

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

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

See DescribeInstanceNodes 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 (*Rabbitmq) DescribeInstanceRequest ¶

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

DescribeInstanceRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstance 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 DescribeInstance for more information on using the DescribeInstance 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 DescribeInstanceRequest method.
req, resp := client.DescribeInstanceRequest(params)

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

func (*Rabbitmq) DescribeInstanceWithContext ¶

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

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

See DescribeInstance 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 (*Rabbitmq) DescribeInstances ¶

func (c *Rabbitmq) DescribeInstances(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstances API operation for rabbitmq.

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 rabbitmq's API operation DescribeInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DescribeInstances

func (*Rabbitmq) DescribeInstancesRequest ¶

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

DescribeInstancesRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstances 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 DescribeInstances for more information on using the DescribeInstances 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 DescribeInstancesRequest method.
req, resp := client.DescribeInstancesRequest(params)

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

func (*Rabbitmq) DescribeInstancesWithContext ¶

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

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

See DescribeInstances 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 (*Rabbitmq) DescribeRegions ¶

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

DescribeRegions API operation for rabbitmq.

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 rabbitmq's API operation DescribeRegions for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DescribeRegions

func (*Rabbitmq) DescribeRegionsRequest ¶

func (c *Rabbitmq) 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)
}

func (*Rabbitmq) DescribeRegionsWithContext ¶

func (c *Rabbitmq) 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 (*Rabbitmq) DescribeSecurityGroupRules ¶

func (c *Rabbitmq) DescribeSecurityGroupRules(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeSecurityGroupRules API operation for rabbitmq.

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 rabbitmq's API operation DescribeSecurityGroupRules for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DescribeSecurityGroupRules

func (*Rabbitmq) DescribeSecurityGroupRulesRequest ¶

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

DescribeSecurityGroupRulesRequest generates a "ksc/request.Request" representing the client's request for the DescribeSecurityGroupRules 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 DescribeSecurityGroupRules for more information on using the DescribeSecurityGroupRules 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 DescribeSecurityGroupRulesRequest method.
req, resp := client.DescribeSecurityGroupRulesRequest(params)

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

func (*Rabbitmq) DescribeSecurityGroupRulesWithContext ¶

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

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

See DescribeSecurityGroupRules 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 (*Rabbitmq) DescribeValidRegion ¶

func (c *Rabbitmq) DescribeValidRegion(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeValidRegion API operation for rabbitmq.

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 rabbitmq's API operation DescribeValidRegion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DescribeValidRegion

func (*Rabbitmq) DescribeValidRegionRequest ¶

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

DescribeValidRegionRequest generates a "ksc/request.Request" representing the client's request for the DescribeValidRegion 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 DescribeValidRegion for more information on using the DescribeValidRegion 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 DescribeValidRegionRequest method.
req, resp := client.DescribeValidRegionRequest(params)

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

func (*Rabbitmq) DescribeValidRegionWithContext ¶

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

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

See DescribeValidRegion 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 (*Rabbitmq) DisableInstancePlugins ¶

func (c *Rabbitmq) DisableInstancePlugins(input *map[string]interface{}) (*map[string]interface{}, error)

DisableInstancePlugins API operation for rabbitmq.

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 rabbitmq's API operation DisableInstancePlugins for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/DisableInstancePlugins

func (*Rabbitmq) DisableInstancePluginsRequest ¶

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

DisableInstancePluginsRequest generates a "ksc/request.Request" representing the client's request for the DisableInstancePlugins 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 DisableInstancePlugins for more information on using the DisableInstancePlugins 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 DisableInstancePluginsRequest method.
req, resp := client.DisableInstancePluginsRequest(params)

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

func (*Rabbitmq) DisableInstancePluginsWithContext ¶

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

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

See DisableInstancePlugins 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 (*Rabbitmq) EnableInstancePlugins ¶

func (c *Rabbitmq) EnableInstancePlugins(input *map[string]interface{}) (*map[string]interface{}, error)

EnableInstancePlugins API operation for rabbitmq.

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 rabbitmq's API operation EnableInstancePlugins for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/EnableInstancePlugins

func (*Rabbitmq) EnableInstancePluginsRequest ¶

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

EnableInstancePluginsRequest generates a "ksc/request.Request" representing the client's request for the EnableInstancePlugins 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 EnableInstancePlugins for more information on using the EnableInstancePlugins 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 EnableInstancePluginsRequest method.
req, resp := client.EnableInstancePluginsRequest(params)

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

func (*Rabbitmq) EnableInstancePluginsWithContext ¶

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

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

See EnableInstancePlugins 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 (*Rabbitmq) ListInstancePlugins ¶

func (c *Rabbitmq) ListInstancePlugins(input *map[string]interface{}) (*map[string]interface{}, error)

ListInstancePlugins API operation for rabbitmq.

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 rabbitmq's API operation ListInstancePlugins for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/ListInstancePlugins

func (*Rabbitmq) ListInstancePluginsRequest ¶

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

ListInstancePluginsRequest generates a "ksc/request.Request" representing the client's request for the ListInstancePlugins 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 ListInstancePlugins for more information on using the ListInstancePlugins 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 ListInstancePluginsRequest method.
req, resp := client.ListInstancePluginsRequest(params)

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

func (*Rabbitmq) ListInstancePluginsWithContext ¶

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

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

See ListInstancePlugins 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 (*Rabbitmq) ModifyBandWidth ¶

func (c *Rabbitmq) ModifyBandWidth(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyBandWidth API operation for rabbitmq.

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 rabbitmq's API operation ModifyBandWidth for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/ModifyBandWidth

func (*Rabbitmq) ModifyBandWidthRequest ¶

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

ModifyBandWidthRequest generates a "ksc/request.Request" representing the client's request for the ModifyBandWidth 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 ModifyBandWidth for more information on using the ModifyBandWidth 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 ModifyBandWidthRequest method.
req, resp := client.ModifyBandWidthRequest(params)

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

func (*Rabbitmq) ModifyBandWidthWithContext ¶

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

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

See ModifyBandWidth 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 (*Rabbitmq) Rename ¶

func (c *Rabbitmq) Rename(input *map[string]interface{}) (*map[string]interface{}, error)

Rename API operation for rabbitmq.

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 rabbitmq's API operation Rename for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/Rename

func (*Rabbitmq) RenameRequest ¶

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

RenameRequest generates a "ksc/request.Request" representing the client's request for the Rename 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 Rename for more information on using the Rename 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 RenameRequest method.
req, resp := client.RenameRequest(params)

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

func (*Rabbitmq) RenameWithContext ¶

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

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

See Rename 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 (*Rabbitmq) ResetPassword ¶

func (c *Rabbitmq) ResetPassword(input *map[string]interface{}) (*map[string]interface{}, error)

ResetPassword API operation for rabbitmq.

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 rabbitmq's API operation ResetPassword for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/ResetPassword

func (*Rabbitmq) ResetPasswordRequest ¶

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

ResetPasswordRequest generates a "ksc/request.Request" representing the client's request for the ResetPassword 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 ResetPassword for more information on using the ResetPassword 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 ResetPasswordRequest method.
req, resp := client.ResetPasswordRequest(params)

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

func (*Rabbitmq) ResetPasswordWithContext ¶

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

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

See ResetPassword 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 (*Rabbitmq) RestartInstance ¶

func (c *Rabbitmq) RestartInstance(input *map[string]interface{}) (*map[string]interface{}, error)

RestartInstance API operation for rabbitmq.

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 rabbitmq's API operation RestartInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/RestartInstance

func (*Rabbitmq) RestartInstanceRequest ¶

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

RestartInstanceRequest generates a "ksc/request.Request" representing the client's request for the RestartInstance 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 RestartInstance for more information on using the RestartInstance 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 RestartInstanceRequest method.
req, resp := client.RestartInstanceRequest(params)

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

func (*Rabbitmq) RestartInstanceWithContext ¶

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

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

See RestartInstance 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 (*Rabbitmq) SupportPlugins ¶

func (c *Rabbitmq) SupportPlugins(input *map[string]interface{}) (*map[string]interface{}, error)

SupportPlugins API operation for rabbitmq.

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 rabbitmq's API operation SupportPlugins for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/SupportPlugins

func (*Rabbitmq) SupportPluginsRequest ¶

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

SupportPluginsRequest generates a "ksc/request.Request" representing the client's request for the SupportPlugins 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 SupportPlugins for more information on using the SupportPlugins 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 SupportPluginsRequest method.
req, resp := client.SupportPluginsRequest(params)

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

func (*Rabbitmq) SupportPluginsWithContext ¶

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

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

See SupportPlugins 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 (*Rabbitmq) UpgradeInstance ¶

func (c *Rabbitmq) UpgradeInstance(input *map[string]interface{}) (*map[string]interface{}, error)

UpgradeInstance API operation for rabbitmq.

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 rabbitmq's API operation UpgradeInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/rabbitmq-2019-10-17/UpgradeInstance

func (*Rabbitmq) UpgradeInstanceRequest ¶

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

UpgradeInstanceRequest generates a "ksc/request.Request" representing the client's request for the UpgradeInstance 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 UpgradeInstance for more information on using the UpgradeInstance 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 UpgradeInstanceRequest method.
req, resp := client.UpgradeInstanceRequest(params)

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

func (*Rabbitmq) UpgradeInstanceWithContext ¶

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

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

See UpgradeInstance 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.

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
rabbitmqiface Package rabbitmqiface provides an interface to enable mocking the rabbitmq service client for testing your code.	Package rabbitmqiface provides an interface to enable mocking the rabbitmq service client for testing your code.

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL