types

package
v1.21.8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 23, 2024 License: Apache-2.0 Imports: 3 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException 

type AccessDeniedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

403 response - You do not have sufficient access to perform this action.

func (*AccessDeniedException) Error 

func (e *AccessDeniedException) Error() string

func (*AccessDeniedException) ErrorCode 

func (e *AccessDeniedException) ErrorCode() string

func (*AccessDeniedException) ErrorFault 

func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

func (*AccessDeniedException) ErrorMessage 

func (e *AccessDeniedException) ErrorMessage() string

type AssertionRule 

type AssertionRule struct {

	// The routing controls that are part of transactions that are evaluated to
	// determine if a request to change a routing control state is allowed. For
	// example, you might include three routing controls, one for each of three Amazon
	// Web Services Regions.
	//
	// This member is required.
	AssertedControls []string

	// The Amazon Resource Name (ARN) of the control panel.
	//
	// This member is required.
	ControlPanelArn *string

	// Name of the assertion rule. You can use any non-white space character in the
	// name.
	//
	// This member is required.
	Name *string

	// The criteria that you set for specific assertion routing controls
	// (AssertedControls) that designate how many routing control states must be ON as
	// the result of a transaction. For example, if you have three assertion routing
	// controls, you might specify ATLEAST 2 for your rule configuration. This means
	// that at least two assertion routing control states must be ON, so that at least
	// two Amazon Web Services Regions have traffic flowing to them.
	//
	// This member is required.
	RuleConfig *RuleConfig

	// The Amazon Resource Name (ARN) of the assertion rule.
	//
	// This member is required.
	SafetyRuleArn *string

	// The deployment status of an assertion rule. Status can be one of the following:
	// PENDING, DEPLOYED, PENDING_DELETION.
	//
	// This member is required.
	Status Status

	// An evaluation period, in milliseconds (ms), during which any request against
	// the target routing controls will fail. This helps prevent "flapping" of state.
	// The wait period is 5000 ms by default, but you can choose a custom value.
	//
	// This member is required.
	WaitPeriodMs *int32

	// The Amazon Web Services account ID of the assertion rule owner.
	Owner *string
	// contains filtered or unexported fields
}

An assertion rule enforces that, when you change a routing control state, that the criteria that you set in the rule configuration is met. Otherwise, the change to the routing control is not accepted. For example, the criteria might be that at least one routing control state is On after the transaction so that traffic continues to flow to at least one cell for the application. This ensures that you avoid a fail-open scenario.

type AssertionRuleUpdate 

type AssertionRuleUpdate struct {

	// The name of the assertion rule. You can use any non-white space character in
	// the name.
	//
	// This member is required.
	Name *string

	// The Amazon Resource Name (ARN) of the assertion rule.
	//
	// This member is required.
	SafetyRuleArn *string

	// An evaluation period, in milliseconds (ms), during which any request against
	// the target routing controls will fail. This helps prevent "flapping" of state.
	// The wait period is 5000 ms by default, but you can choose a custom value.
	//
	// This member is required.
	WaitPeriodMs *int32
	// contains filtered or unexported fields
}

An update to an assertion rule. You can update the name or the evaluation period (wait period). If you don't specify one of the items to update, the item is unchanged.

type Cluster 

type Cluster struct {

	// The Amazon Resource Name (ARN) of the cluster.
	ClusterArn *string

	// Endpoints for a cluster. Specify one of these endpoints when you want to set or
	// retrieve a routing control state in the cluster.
	//
	// To get or update the routing control state, see the Amazon Route 53 Application
	// Recovery Controller Routing Control Actions.
	ClusterEndpoints []ClusterEndpoint

	// The name of the cluster.
	Name *string

	// The Amazon Web Services account ID of the cluster owner.
	Owner *string

	// Deployment status of a resource. Status can be one of the following: PENDING,
	// DEPLOYED, PENDING_DELETION.
	Status Status
	// contains filtered or unexported fields
}

A set of five redundant Regional endpoints against which you can execute API calls to update or get the state of routing controls. You can host multiple control panels and routing controls on one cluster.

type ClusterEndpoint 

type ClusterEndpoint struct {

	// A cluster endpoint. Specify an endpoint and Amazon Web Services Region when you
	// want to set or retrieve a routing control state in the cluster.
	//
	// To get or update the routing control state, see the Amazon Route 53 Application
	// Recovery Controller Routing Control Actions.
	Endpoint *string

	// The Amazon Web Services Region for a cluster endpoint.
	Region *string
	// contains filtered or unexported fields
}

A cluster endpoint. Specify an endpoint when you want to set or retrieve a routing control state in the cluster.

type ConflictException 

type ConflictException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

409 response - ConflictException. You might be using a predefined variable.

func (*ConflictException) Error 

func (e *ConflictException) Error() string

func (*ConflictException) ErrorCode 

func (e *ConflictException) ErrorCode() string

func (*ConflictException) ErrorFault 

func (e *ConflictException) ErrorFault() smithy.ErrorFault

func (*ConflictException) ErrorMessage 

func (e *ConflictException) ErrorMessage() string

type ControlPanel 

type ControlPanel struct {

	// The Amazon Resource Name (ARN) of the cluster that includes the control panel.
	ClusterArn *string

	// The Amazon Resource Name (ARN) of the control panel.
	ControlPanelArn *string

	// A flag that Amazon Route 53 Application Recovery Controller sets to true to
	// designate the default control panel for a cluster. When you create a cluster,
	// Amazon Route 53 Application Recovery Controller creates a control panel, and
	// sets this flag for that control panel. If you create a control panel yourself,
	// this flag is set to false.
	DefaultControlPanel *bool

	// The name of the control panel. You can use any non-white space character in the
	// name.
	Name *string

	// The Amazon Web Services account ID of the control panel owner.
	Owner *string

	// The number of routing controls in the control panel.
	RoutingControlCount *int32

	// The deployment status of control panel. Status can be one of the following:
	// PENDING, DEPLOYED, PENDING_DELETION.
	Status Status
	// contains filtered or unexported fields
}

A control panel represents a group of routing controls that can be changed together in a single transaction.

type GatingRule 

type GatingRule struct {

	// The Amazon Resource Name (ARN) of the control panel.
	//
	// This member is required.
	ControlPanelArn *string

	// An array of gating routing control Amazon Resource Names (ARNs). For a simple
	// "on/off" switch, specify the ARN for one routing control. The gating routing
	// controls are evaluated by the rule configuration that you specify to determine
	// if the target routing control states can be changed.
	//
	// This member is required.
	GatingControls []string

	// The name for the gating rule. You can use any non-white space character in the
	// name.
	//
	// This member is required.
	Name *string

	// The criteria that you set for gating routing controls that designate how many
	// of the routing control states must be ON to allow you to update target routing
	// control states.
	//
	// This member is required.
	RuleConfig *RuleConfig

	// The Amazon Resource Name (ARN) of the gating rule.
	//
	// This member is required.
	SafetyRuleArn *string

	// The deployment status of a gating rule. Status can be one of the following:
	// PENDING, DEPLOYED, PENDING_DELETION.
	//
	// This member is required.
	Status Status

	// An array of target routing control Amazon Resource Names (ARNs) for which the
	// states can only be updated if the rule configuration that you specify evaluates
	// to true for the gating routing control. As a simple example, if you have a
	// single gating control, it acts as an overall "on/off" switch for a set of target
	// routing controls. You can use this to manually override automated failover, for
	// example.
	//
	// This member is required.
	TargetControls []string

	// An evaluation period, in milliseconds (ms), during which any request against
	// the target routing controls will fail. This helps prevent "flapping" of state.
	// The wait period is 5000 ms by default, but you can choose a custom value.
	//
	// This member is required.
	WaitPeriodMs *int32

	// The Amazon Web Services account ID of the gating rule owner.
	Owner *string
	// contains filtered or unexported fields
}

A gating rule verifies that a gating routing control or set of gating routing controls, evaluates as true, based on a rule configuration that you specify, which allows a set of routing control state changes to complete.

For example, if you specify one gating routing control and you set the Type in the rule configuration to OR, that indicates that you must set the gating routing control to On for the rule to evaluate as true; that is, for the gating control "switch" to be "On". When you do that, then you can update the routing control states for the target routing controls that you specify in the gating rule.

type GatingRuleUpdate 

type GatingRuleUpdate struct {

	// The name for the gating rule. You can use any non-white space character in the
	// name.
	//
	// This member is required.
	Name *string

	// The Amazon Resource Name (ARN) of the gating rule.
	//
	// This member is required.
	SafetyRuleArn *string

	// An evaluation period, in milliseconds (ms), during which any request against
	// the target routing controls will fail. This helps prevent "flapping" of state.
	// The wait period is 5000 ms by default, but you can choose a custom value.
	//
	// This member is required.
	WaitPeriodMs *int32
	// contains filtered or unexported fields
}

Update to a gating rule. You can update the name or the evaluation period (wait period). If you don't specify one of the items to update, the item is unchanged.

type InternalServerException 

type InternalServerException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

500 response - InternalServiceError. Temporary service error. Retry the request.

func (*InternalServerException) Error 

func (e *InternalServerException) Error() string

func (*InternalServerException) ErrorCode 

func (e *InternalServerException) ErrorCode() string

func (*InternalServerException) ErrorFault 

func (e *InternalServerException) ErrorFault() smithy.ErrorFault

func (*InternalServerException) ErrorMessage 

func (e *InternalServerException) ErrorMessage() string

type NewAssertionRule 

type NewAssertionRule struct {

	// The routing controls that are part of transactions that are evaluated to
	// determine if a request to change a routing control state is allowed. For
	// example, you might include three routing controls, one for each of three Amazon
	// Web Services Regions.
	//
	// This member is required.
	AssertedControls []string

	// The Amazon Resource Name (ARN) for the control panel.
	//
	// This member is required.
	ControlPanelArn *string

	// The name of the assertion rule. You can use any non-white space character in
	// the name.
	//
	// This member is required.
	Name *string

	// The criteria that you set for specific assertion controls (routing controls)
	// that designate how many control states must be ON as the result of a
	// transaction. For example, if you have three assertion controls, you might
	// specify ATLEAST 2 for your rule configuration. This means that at least two
	// assertion controls must be ON, so that at least two Amazon Web Services Regions
	// have traffic flowing to them.
	//
	// This member is required.
	RuleConfig *RuleConfig

	// An evaluation period, in milliseconds (ms), during which any request against
	// the target routing controls will fail. This helps prevent "flapping" of state.
	// The wait period is 5000 ms by default, but you can choose a custom value.
	//
	// This member is required.
	WaitPeriodMs *int32
	// contains filtered or unexported fields
}

A new assertion rule for a control panel.

type NewGatingRule 

type NewGatingRule struct {

	// The Amazon Resource Name (ARN) of the control panel.
	//
	// This member is required.
	ControlPanelArn *string

	// The gating controls for the new gating rule. That is, routing controls that are
	// evaluated by the rule configuration that you specify.
	//
	// This member is required.
	GatingControls []string

	// The name for the new gating rule.
	//
	// This member is required.
	Name *string

	// The criteria that you set for specific gating controls (routing controls) that
	// designate how many control states must be ON to allow you to change (set or
	// unset) the target control states.
	//
	// This member is required.
	RuleConfig *RuleConfig

	// Routing controls that can only be set or unset if the specified RuleConfig
	// evaluates to true for the specified GatingControls. For example, say you have
	// three gating controls, one for each of three Amazon Web Services Regions. Now
	// you specify ATLEAST 2 as your RuleConfig. With these settings, you can only
	// change (set or unset) the routing controls that you have specified as
	// TargetControls if that rule evaluates to true.
	//
	// In other words, your ability to change the routing controls that you have
	// specified as TargetControls is gated by the rule that you set for the routing
	// controls in GatingControls.
	//
	// This member is required.
	TargetControls []string

	// An evaluation period, in milliseconds (ms), during which any request against
	// the target routing controls will fail. This helps prevent "flapping" of state.
	// The wait period is 5000 ms by default, but you can choose a custom value.
	//
	// This member is required.
	WaitPeriodMs *int32
	// contains filtered or unexported fields
}

A new gating rule for a control panel.

type ResourceNotFoundException 

type ResourceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

404 response - MalformedQueryString. The query string contains a syntax error or resource not found.

func (*ResourceNotFoundException) Error 

func (e *ResourceNotFoundException) Error() string

func (*ResourceNotFoundException) ErrorCode 

func (e *ResourceNotFoundException) ErrorCode() string

func (*ResourceNotFoundException) ErrorFault 

func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault

func (*ResourceNotFoundException) ErrorMessage 

func (e *ResourceNotFoundException) ErrorMessage() string

type RoutingControl 

type RoutingControl struct {

	// The Amazon Resource Name (ARN) of the control panel that includes the routing
	// control.
	ControlPanelArn *string

	// The name of the routing control.
	Name *string

	// The Amazon Web Services account ID of the routing control owner.
	Owner *string

	// The Amazon Resource Name (ARN) of the routing control.
	RoutingControlArn *string

	// The deployment status of a routing control. Status can be one of the following:
	// PENDING, DEPLOYED, PENDING_DELETION.
	Status Status
	// contains filtered or unexported fields
}

A routing control has one of two states: ON and OFF. You can map the routing control state to the state of an Amazon Route 53 health check, which can be used to control traffic routing.

type Rule 

type Rule struct {

	// An assertion rule enforces that, when a routing control state is changed, the
	// criteria set by the rule configuration is met. Otherwise, the change to the
	// routing control state is not accepted. For example, the criteria might be that
	// at least one routing control state is On after the transaction so that traffic
	// continues to flow to at least one cell for the application. This ensures that
	// you avoid a fail-open scenario.
	ASSERTION *AssertionRule

	// A gating rule verifies that a gating routing control or set of gating routing
	// controls, evaluates as true, based on a rule configuration that you specify,
	// which allows a set of routing control state changes to complete.
	//
	// For example, if you specify one gating routing control and you set the Type in
	// the rule configuration to OR, that indicates that you must set the gating
	// routing control to On for the rule to evaluate as true; that is, for the gating
	// control "switch" to be "On". When you do that, then you can update the routing
	// control states for the target routing controls that you specify in the gating
	// rule.
	GATING *GatingRule
	// contains filtered or unexported fields
}

A safety rule. A safety rule can be an assertion rule or a gating rule.

type RuleConfig 

type RuleConfig struct {

	// Logical negation of the rule. If the rule would usually evaluate true, it's
	// evaluated as false, and vice versa.
	//
	// This member is required.
	Inverted *bool

	// The value of N, when you specify an ATLEAST rule type. That is, Threshold is
	// the number of controls that must be set when you specify an ATLEAST type.
	//
	// This member is required.
	Threshold *int32

	// A rule can be one of the following: ATLEAST, AND, or OR.
	//
	// This member is required.
	Type RuleType
	// contains filtered or unexported fields
}

The rule configuration for an assertion rule. That is, the criteria that you set for specific assertion controls (routing controls) that specify how many control states must be ON after a transaction completes.

type RuleType 

type RuleType string
const (
	RuleTypeAtleast RuleType = "ATLEAST"
	RuleTypeAnd     RuleType = "AND"
	RuleTypeOr      RuleType = "OR"
)

Enum values for RuleType

func (RuleType) Values 

func (RuleType) Values() []RuleType

Values returns all known values for RuleType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ServiceQuotaExceededException 

type ServiceQuotaExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

402 response - You attempted to create more resources than the service allows based on service quotas.

func (*ServiceQuotaExceededException) Error 

func (e *ServiceQuotaExceededException) Error() string

func (*ServiceQuotaExceededException) ErrorCode 

func (e *ServiceQuotaExceededException) ErrorCode() string

func (*ServiceQuotaExceededException) ErrorFault 

func (e *ServiceQuotaExceededException) ErrorFault() smithy.ErrorFault

func (*ServiceQuotaExceededException) ErrorMessage 

func (e *ServiceQuotaExceededException) ErrorMessage() string

type Status 

type Status string
const (
	StatusPending         Status = "PENDING"
	StatusDeployed        Status = "DEPLOYED"
	StatusPendingDeletion Status = "PENDING_DELETION"
)

Enum values for Status

func (Status) Values 

func (Status) Values() []Status

Values returns all known values for Status. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ThrottlingException 

type ThrottlingException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

429 response - LimitExceededException or TooManyRequestsException.

func (*ThrottlingException) Error 

func (e *ThrottlingException) Error() string

func (*ThrottlingException) ErrorCode 

func (e *ThrottlingException) ErrorCode() string

func (*ThrottlingException) ErrorFault 

func (e *ThrottlingException) ErrorFault() smithy.ErrorFault

func (*ThrottlingException) ErrorMessage 

func (e *ThrottlingException) ErrorMessage() string

type ValidationException 

type ValidationException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

400 response - Multiple causes. For example, you might have a malformed query string and input parameter might be out of range, or you might have used parameters together incorrectly.

func (*ValidationException) Error 

func (e *ValidationException) Error() string

func (*ValidationException) ErrorCode 

func (e *ValidationException) ErrorCode() string

func (*ValidationException) ErrorFault 

func (e *ValidationException) ErrorFault() smithy.ErrorFault

func (*ValidationException) ErrorMessage 

func (e *ValidationException) ErrorMessage() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.