mongodb

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 = "mongodb"   // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "mongodb"   // ServiceID is a unique identifer of a specific service.
)

Service information constants

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Mongodb ¶

type Mongodb struct {
	*client.Client
}

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

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

extraNew create int can support ssl or region locate set

func New ¶

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

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

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

func SdkNew ¶

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

SdkNew create int can support ssl or region locate set

func (*Mongodb) AddClusterNode ¶

func (c *Mongodb) AddClusterNode(input *map[string]interface{}) (*map[string]interface{}, error)

AddClusterNode API operation for mongodb.

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 mongodb's API operation AddClusterNode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/AddClusterNode

func (*Mongodb) AddClusterNodeRequest ¶

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

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

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

func (*Mongodb) AddClusterNodeWithContext ¶

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

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

See AddClusterNode 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 (*Mongodb) AddSecondaryInstance ¶

func (c *Mongodb) AddSecondaryInstance(input *map[string]interface{}) (*map[string]interface{}, error)

AddSecondaryInstance API operation for mongodb.

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 mongodb's API operation AddSecondaryInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/AddSecondaryInstance

func (*Mongodb) AddSecondaryInstanceRequest ¶

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

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

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

func (*Mongodb) AddSecondaryInstanceWithContext ¶

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

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

See AddSecondaryInstance 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 (*Mongodb) AddSecurityGroupRule ¶

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

AddSecurityGroupRule API operation for mongodb.

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

func (*Mongodb) AddSecurityGroupRuleRequest ¶

func (c *Mongodb) 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 (*Mongodb) AddSecurityGroupRuleWithContext ¶

func (c *Mongodb) 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 (*Mongodb) CreateMongoDBInstance ¶

func (c *Mongodb) CreateMongoDBInstance(input *map[string]interface{}) (*map[string]interface{}, error)

CreateMongoDBInstance API operation for mongodb.

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 mongodb's API operation CreateMongoDBInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/CreateMongoDBInstance

func (*Mongodb) CreateMongoDBInstanceRequest ¶

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

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

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

func (*Mongodb) CreateMongoDBInstanceWithContext ¶

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

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

See CreateMongoDBInstance 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 (*Mongodb) CreateMongoDBShardInstance ¶

func (c *Mongodb) CreateMongoDBShardInstance(input *map[string]interface{}) (*map[string]interface{}, error)

CreateMongoDBShardInstance API operation for mongodb.

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 mongodb's API operation CreateMongoDBShardInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/CreateMongoDBShardInstance

func (*Mongodb) CreateMongoDBShardInstanceRequest ¶

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

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

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

func (*Mongodb) CreateMongoDBShardInstanceWithContext ¶

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

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

See CreateMongoDBShardInstance 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 (*Mongodb) CreateMongoDBSnapshot ¶

func (c *Mongodb) CreateMongoDBSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

CreateMongoDBSnapshot API operation for mongodb.

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 mongodb's API operation CreateMongoDBSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/CreateMongoDBSnapshot

func (*Mongodb) CreateMongoDBSnapshotRequest ¶

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

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

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

func (*Mongodb) CreateMongoDBSnapshotWithContext ¶

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

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

See CreateMongoDBSnapshot 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 (*Mongodb) DeleteClusterNode ¶

func (c *Mongodb) DeleteClusterNode(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteClusterNode API operation for mongodb.

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 mongodb's API operation DeleteClusterNode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/DeleteClusterNode

func (*Mongodb) DeleteClusterNodeRequest ¶

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

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

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

func (*Mongodb) DeleteClusterNodeWithContext ¶

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

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

See DeleteClusterNode 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 (*Mongodb) DeleteMongoDBInstance ¶

func (c *Mongodb) DeleteMongoDBInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteMongoDBInstance API operation for mongodb.

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 mongodb's API operation DeleteMongoDBInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/DeleteMongoDBInstance

func (*Mongodb) DeleteMongoDBInstanceRequest ¶

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

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

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

func (*Mongodb) DeleteMongoDBInstanceWithContext ¶

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

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

See DeleteMongoDBInstance 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 (*Mongodb) DeleteMongoDBSnapshot ¶

func (c *Mongodb) DeleteMongoDBSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteMongoDBSnapshot API operation for mongodb.

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 mongodb's API operation DeleteMongoDBSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/DeleteMongoDBSnapshot

func (*Mongodb) DeleteMongoDBSnapshotRequest ¶

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

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

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

func (*Mongodb) DeleteMongoDBSnapshotWithContext ¶

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

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

See DeleteMongoDBSnapshot 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 (*Mongodb) DeleteSecurityGroupRules ¶

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

DeleteSecurityGroupRules API operation for mongodb.

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

func (*Mongodb) DeleteSecurityGroupRulesRequest ¶

func (c *Mongodb) 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 (*Mongodb) DeleteSecurityGroupRulesWithContext ¶

func (c *Mongodb) 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 (*Mongodb) DescribeMongoDBInstance ¶

func (c *Mongodb) DescribeMongoDBInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeMongoDBInstance API operation for mongodb.

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 mongodb's API operation DescribeMongoDBInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/DescribeMongoDBInstance

func (*Mongodb) DescribeMongoDBInstanceNode ¶

func (c *Mongodb) DescribeMongoDBInstanceNode(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeMongoDBInstanceNode API operation for mongodb.

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 mongodb's API operation DescribeMongoDBInstanceNode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/DescribeMongoDBInstanceNode

func (*Mongodb) DescribeMongoDBInstanceNodeRequest ¶

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

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

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

func (*Mongodb) DescribeMongoDBInstanceNodeWithContext ¶

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

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

See DescribeMongoDBInstanceNode 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 (*Mongodb) DescribeMongoDBInstanceRequest ¶

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

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

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

func (*Mongodb) DescribeMongoDBInstanceWithContext ¶

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

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

See DescribeMongoDBInstance 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 (*Mongodb) DescribeMongoDBInstances ¶

func (c *Mongodb) DescribeMongoDBInstances(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeMongoDBInstances API operation for mongodb.

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 mongodb's API operation DescribeMongoDBInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/DescribeMongoDBInstances

func (*Mongodb) DescribeMongoDBInstancesRequest ¶

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

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

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

func (*Mongodb) DescribeMongoDBInstancesWithContext ¶

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

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

See DescribeMongoDBInstances 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 (*Mongodb) DescribeMongoDBShardNode ¶

func (c *Mongodb) DescribeMongoDBShardNode(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeMongoDBShardNode API operation for mongodb.

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 mongodb's API operation DescribeMongoDBShardNode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/DescribeMongoDBShardNode

func (*Mongodb) DescribeMongoDBShardNodeRequest ¶

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

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

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

func (*Mongodb) DescribeMongoDBShardNodeWithContext ¶

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

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

See DescribeMongoDBShardNode 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 (*Mongodb) DescribeMongoDBSnapshot ¶

func (c *Mongodb) DescribeMongoDBSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeMongoDBSnapshot API operation for mongodb.

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 mongodb's API operation DescribeMongoDBSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/DescribeMongoDBSnapshot

func (*Mongodb) DescribeMongoDBSnapshotRequest ¶

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

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

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

func (*Mongodb) DescribeMongoDBSnapshotWithContext ¶

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

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

See DescribeMongoDBSnapshot 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 (*Mongodb) DescribeRegions ¶

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

DescribeRegions API operation for mongodb.

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

func (*Mongodb) DescribeRegionsRequest ¶

func (c *Mongodb) 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 (*Mongodb) DescribeRegionsWithContext ¶

func (c *Mongodb) 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 (*Mongodb) ListSecurityGroupRules ¶

func (c *Mongodb) ListSecurityGroupRules(input *map[string]interface{}) (*map[string]interface{}, error)

ListSecurityGroupRules API operation for mongodb.

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 mongodb's API operation ListSecurityGroupRules for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/ListSecurityGroupRules

func (*Mongodb) ListSecurityGroupRulesRequest ¶

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

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

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

func (*Mongodb) ListSecurityGroupRulesWithContext ¶

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

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

See ListSecurityGroupRules 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 (*Mongodb) RenameMongoDBInstance ¶

func (c *Mongodb) RenameMongoDBInstance(input *map[string]interface{}) (*map[string]interface{}, error)

RenameMongoDBInstance API operation for mongodb.

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 mongodb's API operation RenameMongoDBInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/RenameMongoDBInstance

func (*Mongodb) RenameMongoDBInstanceRequest ¶

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

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

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

func (*Mongodb) RenameMongoDBInstanceWithContext ¶

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

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

See RenameMongoDBInstance 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 (*Mongodb) RenameMongoDBSnapshot ¶

func (c *Mongodb) RenameMongoDBSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

RenameMongoDBSnapshot API operation for mongodb.

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 mongodb's API operation RenameMongoDBSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/RenameMongoDBSnapshot

func (*Mongodb) RenameMongoDBSnapshotRequest ¶

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

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

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

func (*Mongodb) RenameMongoDBSnapshotWithContext ¶

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

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

See RenameMongoDBSnapshot 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 (*Mongodb) ResetPasswordMongoDBInstance ¶

func (c *Mongodb) ResetPasswordMongoDBInstance(input *map[string]interface{}) (*map[string]interface{}, error)

ResetPasswordMongoDBInstance API operation for mongodb.

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 mongodb's API operation ResetPasswordMongoDBInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/ResetPasswordMongoDBInstance

func (*Mongodb) ResetPasswordMongoDBInstanceRequest ¶

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

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

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

func (*Mongodb) ResetPasswordMongoDBInstanceWithContext ¶

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

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

See ResetPasswordMongoDBInstance 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 (*Mongodb) RestartMongoDBInstance ¶

func (c *Mongodb) RestartMongoDBInstance(input *map[string]interface{}) (*map[string]interface{}, error)

RestartMongoDBInstance API operation for mongodb.

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 mongodb's API operation RestartMongoDBInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/RestartMongoDBInstance

func (*Mongodb) RestartMongoDBInstanceRequest ¶

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

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

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

func (*Mongodb) RestartMongoDBInstanceWithContext ¶

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

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

See RestartMongoDBInstance 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 (*Mongodb) SetMongoDBTimingSnapshot ¶

func (c *Mongodb) SetMongoDBTimingSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

SetMongoDBTimingSnapshot API operation for mongodb.

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 mongodb's API operation SetMongoDBTimingSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/SetMongoDBTimingSnapshot

func (*Mongodb) SetMongoDBTimingSnapshotRequest ¶

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

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

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

func (*Mongodb) SetMongoDBTimingSnapshotWithContext ¶

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

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

See SetMongoDBTimingSnapshot 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 (*Mongodb) UpdateMongoDBInstance ¶

func (c *Mongodb) UpdateMongoDBInstance(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateMongoDBInstance API operation for mongodb.

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 mongodb's API operation UpdateMongoDBInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/UpdateMongoDBInstance

func (*Mongodb) UpdateMongoDBInstanceCluster ¶

func (c *Mongodb) UpdateMongoDBInstanceCluster(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateMongoDBInstanceCluster API operation for mongodb.

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 mongodb's API operation UpdateMongoDBInstanceCluster for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/mongodb-2017-01-01/UpdateMongoDBInstanceCluster

func (*Mongodb) UpdateMongoDBInstanceClusterRequest ¶

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

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

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

func (*Mongodb) UpdateMongoDBInstanceClusterWithContext ¶

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

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

See UpdateMongoDBInstanceCluster 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 (*Mongodb) UpdateMongoDBInstanceRequest ¶

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

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

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

func (*Mongodb) UpdateMongoDBInstanceWithContext ¶

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

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

See UpdateMongoDBInstance 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
mongodbiface Package mongodbiface provides an interface to enable mocking the mongodb service client for testing your code.	Package mongodbiface provides an interface to enable mocking the mongodb service client for testing your code.

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