gwlb

package
v1.63.65 Latest Latest
Warning

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

 Go to latest Published: Dec 6, 2024 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var EndpointMap map[string]string

EndpointMap Endpoint Data

View Source 
var EndpointType = "regional"

EndpointType regional or central

Functions

func GetEndpointMap added in v1.63.36 

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType added in v1.63.36 

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty added in v1.63.36 

func SetClientProperty(client *Client, propertyName string, propertyValue interface{})

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient added in v1.63.36 

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types

type AddServersToServerGroupRequest 

type AddServersToServerGroupRequest struct {
	*requests.RpcRequest
	ClientToken   string                            `position:"Body" name:"ClientToken"`
	ServerGroupId string                            `position:"Body" name:"ServerGroupId"`
	Servers       *[]AddServersToServerGroupServers `position:"Body" name:"Servers"  type:"Repeated"`
	DryRun        requests.Boolean                  `position:"Body" name:"DryRun"`
}

AddServersToServerGroupRequest is the request struct for api AddServersToServerGroup

func CreateAddServersToServerGroupRequest 

func CreateAddServersToServerGroupRequest() (request *AddServersToServerGroupRequest)

CreateAddServersToServerGroupRequest creates a request to invoke AddServersToServerGroup API

type AddServersToServerGroupResponse 

type AddServersToServerGroupResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

AddServersToServerGroupResponse is the response struct for api AddServersToServerGroup

func CreateAddServersToServerGroupResponse 

func CreateAddServersToServerGroupResponse() (response *AddServersToServerGroupResponse)

CreateAddServersToServerGroupResponse creates a response to parse from AddServersToServerGroup response

type AddServersToServerGroupServers 

type AddServersToServerGroupServers struct {
	Port       string `name:"Port"`
	ServerId   string `name:"ServerId"`
	ServerIp   string `name:"ServerIp"`
	ServerType string `name:"ServerType"`
}

AddServersToServerGroupServers is a repeated param struct in AddServersToServerGroupRequest

type Client 

type Client struct {
	sdk.Client
}

Client is the sdk client struct, each func corresponds to an OpenAPI

func NewClient 

func NewClient() (client *Client, err error)

NewClient creates a sdk client with environment variables

func NewClientWithAccessKey 

func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)

NewClientWithAccessKey is a shortcut to create sdk client with accesskey usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithEcsRamRole 

func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)

NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithOptions 

func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)

NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential this is the common api to create a sdk client

func NewClientWithProvider 

func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)

NewClientWithProvider creates a sdk client with providers usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArn 

func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArnAndPolicy 

func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn and policy usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRsaKeyPair 

func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)

NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithStsToken 

func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)

NewClientWithStsToken is a shortcut to create sdk client with sts token usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func (*Client) AddServersToServerGroup 

func (client *Client) AddServersToServerGroup(request *AddServersToServerGroupRequest) (response *AddServersToServerGroupResponse, err error)

AddServersToServerGroup invokes the gwlb.AddServersToServerGroup API synchronously

func (*Client) AddServersToServerGroupWithCallback 

func (client *Client) AddServersToServerGroupWithCallback(request *AddServersToServerGroupRequest, callback func(response *AddServersToServerGroupResponse, err error)) <-chan int

AddServersToServerGroupWithCallback invokes the gwlb.AddServersToServerGroup API asynchronously

func (*Client) AddServersToServerGroupWithChan 

func (client *Client) AddServersToServerGroupWithChan(request *AddServersToServerGroupRequest) (<-chan *AddServersToServerGroupResponse, <-chan error)

AddServersToServerGroupWithChan invokes the gwlb.AddServersToServerGroup API asynchronously

func (*Client) CreateListener 

func (client *Client) CreateListener(request *CreateListenerRequest) (response *CreateListenerResponse, err error)

CreateListener invokes the gwlb.CreateListener API synchronously

func (*Client) CreateListenerWithCallback 

func (client *Client) CreateListenerWithCallback(request *CreateListenerRequest, callback func(response *CreateListenerResponse, err error)) <-chan int

CreateListenerWithCallback invokes the gwlb.CreateListener API asynchronously

func (*Client) CreateListenerWithChan 

func (client *Client) CreateListenerWithChan(request *CreateListenerRequest) (<-chan *CreateListenerResponse, <-chan error)

CreateListenerWithChan invokes the gwlb.CreateListener API asynchronously

func (*Client) CreateLoadBalancer 

func (client *Client) CreateLoadBalancer(request *CreateLoadBalancerRequest) (response *CreateLoadBalancerResponse, err error)

CreateLoadBalancer invokes the gwlb.CreateLoadBalancer API synchronously

func (*Client) CreateLoadBalancerWithCallback 

func (client *Client) CreateLoadBalancerWithCallback(request *CreateLoadBalancerRequest, callback func(response *CreateLoadBalancerResponse, err error)) <-chan int

CreateLoadBalancerWithCallback invokes the gwlb.CreateLoadBalancer API asynchronously

func (*Client) CreateLoadBalancerWithChan 

func (client *Client) CreateLoadBalancerWithChan(request *CreateLoadBalancerRequest) (<-chan *CreateLoadBalancerResponse, <-chan error)

CreateLoadBalancerWithChan invokes the gwlb.CreateLoadBalancer API asynchronously

func (*Client) CreateServerGroup 

func (client *Client) CreateServerGroup(request *CreateServerGroupRequest) (response *CreateServerGroupResponse, err error)

CreateServerGroup invokes the gwlb.CreateServerGroup API synchronously

func (*Client) CreateServerGroupWithCallback 

func (client *Client) CreateServerGroupWithCallback(request *CreateServerGroupRequest, callback func(response *CreateServerGroupResponse, err error)) <-chan int

CreateServerGroupWithCallback invokes the gwlb.CreateServerGroup API asynchronously

func (*Client) CreateServerGroupWithChan 

func (client *Client) CreateServerGroupWithChan(request *CreateServerGroupRequest) (<-chan *CreateServerGroupResponse, <-chan error)

CreateServerGroupWithChan invokes the gwlb.CreateServerGroup API asynchronously

func (*Client) DeleteListener 

func (client *Client) DeleteListener(request *DeleteListenerRequest) (response *DeleteListenerResponse, err error)

DeleteListener invokes the gwlb.DeleteListener API synchronously

func (*Client) DeleteListenerWithCallback 

func (client *Client) DeleteListenerWithCallback(request *DeleteListenerRequest, callback func(response *DeleteListenerResponse, err error)) <-chan int

DeleteListenerWithCallback invokes the gwlb.DeleteListener API asynchronously

func (*Client) DeleteListenerWithChan 

func (client *Client) DeleteListenerWithChan(request *DeleteListenerRequest) (<-chan *DeleteListenerResponse, <-chan error)

DeleteListenerWithChan invokes the gwlb.DeleteListener API asynchronously

func (*Client) DeleteLoadBalancer 

func (client *Client) DeleteLoadBalancer(request *DeleteLoadBalancerRequest) (response *DeleteLoadBalancerResponse, err error)

DeleteLoadBalancer invokes the gwlb.DeleteLoadBalancer API synchronously

func (*Client) DeleteLoadBalancerWithCallback 

func (client *Client) DeleteLoadBalancerWithCallback(request *DeleteLoadBalancerRequest, callback func(response *DeleteLoadBalancerResponse, err error)) <-chan int

DeleteLoadBalancerWithCallback invokes the gwlb.DeleteLoadBalancer API asynchronously

func (*Client) DeleteLoadBalancerWithChan 

func (client *Client) DeleteLoadBalancerWithChan(request *DeleteLoadBalancerRequest) (<-chan *DeleteLoadBalancerResponse, <-chan error)

DeleteLoadBalancerWithChan invokes the gwlb.DeleteLoadBalancer API asynchronously

func (*Client) DeleteServerGroup 

func (client *Client) DeleteServerGroup(request *DeleteServerGroupRequest) (response *DeleteServerGroupResponse, err error)

DeleteServerGroup invokes the gwlb.DeleteServerGroup API synchronously

func (*Client) DeleteServerGroupWithCallback 

func (client *Client) DeleteServerGroupWithCallback(request *DeleteServerGroupRequest, callback func(response *DeleteServerGroupResponse, err error)) <-chan int

DeleteServerGroupWithCallback invokes the gwlb.DeleteServerGroup API asynchronously

func (*Client) DeleteServerGroupWithChan 

func (client *Client) DeleteServerGroupWithChan(request *DeleteServerGroupRequest) (<-chan *DeleteServerGroupResponse, <-chan error)

DeleteServerGroupWithChan invokes the gwlb.DeleteServerGroup API asynchronously

func (*Client) DescribeRegions 

func (client *Client) DescribeRegions(request *DescribeRegionsRequest) (response *DescribeRegionsResponse, err error)

DescribeRegions invokes the gwlb.DescribeRegions API synchronously

func (*Client) DescribeRegionsWithCallback 

func (client *Client) DescribeRegionsWithCallback(request *DescribeRegionsRequest, callback func(response *DescribeRegionsResponse, err error)) <-chan int

DescribeRegionsWithCallback invokes the gwlb.DescribeRegions API asynchronously

func (*Client) DescribeRegionsWithChan 

func (client *Client) DescribeRegionsWithChan(request *DescribeRegionsRequest) (<-chan *DescribeRegionsResponse, <-chan error)

DescribeRegionsWithChan invokes the gwlb.DescribeRegions API asynchronously

func (*Client) DescribeZones 

func (client *Client) DescribeZones(request *DescribeZonesRequest) (response *DescribeZonesResponse, err error)

DescribeZones invokes the gwlb.DescribeZones API synchronously

func (*Client) DescribeZonesWithCallback 

func (client *Client) DescribeZonesWithCallback(request *DescribeZonesRequest, callback func(response *DescribeZonesResponse, err error)) <-chan int

DescribeZonesWithCallback invokes the gwlb.DescribeZones API asynchronously

func (*Client) DescribeZonesWithChan 

func (client *Client) DescribeZonesWithChan(request *DescribeZonesRequest) (<-chan *DescribeZonesResponse, <-chan error)

DescribeZonesWithChan invokes the gwlb.DescribeZones API asynchronously

func (*Client) GetListenerAttribute 

func (client *Client) GetListenerAttribute(request *GetListenerAttributeRequest) (response *GetListenerAttributeResponse, err error)

GetListenerAttribute invokes the gwlb.GetListenerAttribute API synchronously

func (*Client) GetListenerAttributeWithCallback 

func (client *Client) GetListenerAttributeWithCallback(request *GetListenerAttributeRequest, callback func(response *GetListenerAttributeResponse, err error)) <-chan int

GetListenerAttributeWithCallback invokes the gwlb.GetListenerAttribute API asynchronously

func (*Client) GetListenerAttributeWithChan 

func (client *Client) GetListenerAttributeWithChan(request *GetListenerAttributeRequest) (<-chan *GetListenerAttributeResponse, <-chan error)

GetListenerAttributeWithChan invokes the gwlb.GetListenerAttribute API asynchronously

func (*Client) GetListenerHealthStatus 

func (client *Client) GetListenerHealthStatus(request *GetListenerHealthStatusRequest) (response *GetListenerHealthStatusResponse, err error)

GetListenerHealthStatus invokes the gwlb.GetListenerHealthStatus API synchronously

func (*Client) GetListenerHealthStatusWithCallback 

func (client *Client) GetListenerHealthStatusWithCallback(request *GetListenerHealthStatusRequest, callback func(response *GetListenerHealthStatusResponse, err error)) <-chan int

GetListenerHealthStatusWithCallback invokes the gwlb.GetListenerHealthStatus API asynchronously

func (*Client) GetListenerHealthStatusWithChan 

func (client *Client) GetListenerHealthStatusWithChan(request *GetListenerHealthStatusRequest) (<-chan *GetListenerHealthStatusResponse, <-chan error)

GetListenerHealthStatusWithChan invokes the gwlb.GetListenerHealthStatus API asynchronously

func (*Client) GetLoadBalancerAttribute 

func (client *Client) GetLoadBalancerAttribute(request *GetLoadBalancerAttributeRequest) (response *GetLoadBalancerAttributeResponse, err error)

GetLoadBalancerAttribute invokes the gwlb.GetLoadBalancerAttribute API synchronously

func (*Client) GetLoadBalancerAttributeWithCallback 

func (client *Client) GetLoadBalancerAttributeWithCallback(request *GetLoadBalancerAttributeRequest, callback func(response *GetLoadBalancerAttributeResponse, err error)) <-chan int

GetLoadBalancerAttributeWithCallback invokes the gwlb.GetLoadBalancerAttribute API asynchronously

func (*Client) GetLoadBalancerAttributeWithChan 

func (client *Client) GetLoadBalancerAttributeWithChan(request *GetLoadBalancerAttributeRequest) (<-chan *GetLoadBalancerAttributeResponse, <-chan error)

GetLoadBalancerAttributeWithChan invokes the gwlb.GetLoadBalancerAttribute API asynchronously

func (*Client) ListListeners 

func (client *Client) ListListeners(request *ListListenersRequest) (response *ListListenersResponse, err error)

ListListeners invokes the gwlb.ListListeners API synchronously

func (*Client) ListListenersWithCallback 

func (client *Client) ListListenersWithCallback(request *ListListenersRequest, callback func(response *ListListenersResponse, err error)) <-chan int

ListListenersWithCallback invokes the gwlb.ListListeners API asynchronously

func (*Client) ListListenersWithChan 

func (client *Client) ListListenersWithChan(request *ListListenersRequest) (<-chan *ListListenersResponse, <-chan error)

ListListenersWithChan invokes the gwlb.ListListeners API asynchronously

func (*Client) ListLoadBalancers 

func (client *Client) ListLoadBalancers(request *ListLoadBalancersRequest) (response *ListLoadBalancersResponse, err error)

ListLoadBalancers invokes the gwlb.ListLoadBalancers API synchronously

func (*Client) ListLoadBalancersWithCallback 

func (client *Client) ListLoadBalancersWithCallback(request *ListLoadBalancersRequest, callback func(response *ListLoadBalancersResponse, err error)) <-chan int

ListLoadBalancersWithCallback invokes the gwlb.ListLoadBalancers API asynchronously

func (*Client) ListLoadBalancersWithChan 

func (client *Client) ListLoadBalancersWithChan(request *ListLoadBalancersRequest) (<-chan *ListLoadBalancersResponse, <-chan error)

ListLoadBalancersWithChan invokes the gwlb.ListLoadBalancers API asynchronously

func (*Client) ListServerGroupServers 

func (client *Client) ListServerGroupServers(request *ListServerGroupServersRequest) (response *ListServerGroupServersResponse, err error)

ListServerGroupServers invokes the gwlb.ListServerGroupServers API synchronously

func (*Client) ListServerGroupServersWithCallback 

func (client *Client) ListServerGroupServersWithCallback(request *ListServerGroupServersRequest, callback func(response *ListServerGroupServersResponse, err error)) <-chan int

ListServerGroupServersWithCallback invokes the gwlb.ListServerGroupServers API asynchronously

func (*Client) ListServerGroupServersWithChan 

func (client *Client) ListServerGroupServersWithChan(request *ListServerGroupServersRequest) (<-chan *ListServerGroupServersResponse, <-chan error)

ListServerGroupServersWithChan invokes the gwlb.ListServerGroupServers API asynchronously

func (*Client) ListServerGroups 

func (client *Client) ListServerGroups(request *ListServerGroupsRequest) (response *ListServerGroupsResponse, err error)

ListServerGroups invokes the gwlb.ListServerGroups API synchronously

func (*Client) ListServerGroupsWithCallback 

func (client *Client) ListServerGroupsWithCallback(request *ListServerGroupsRequest, callback func(response *ListServerGroupsResponse, err error)) <-chan int

ListServerGroupsWithCallback invokes the gwlb.ListServerGroups API asynchronously

func (*Client) ListServerGroupsWithChan 

func (client *Client) ListServerGroupsWithChan(request *ListServerGroupsRequest) (<-chan *ListServerGroupsResponse, <-chan error)

ListServerGroupsWithChan invokes the gwlb.ListServerGroups API asynchronously

func (*Client) ListTagResources 

func (client *Client) ListTagResources(request *ListTagResourcesRequest) (response *ListTagResourcesResponse, err error)

ListTagResources invokes the gwlb.ListTagResources API synchronously

func (*Client) ListTagResourcesWithCallback 

func (client *Client) ListTagResourcesWithCallback(request *ListTagResourcesRequest, callback func(response *ListTagResourcesResponse, err error)) <-chan int

ListTagResourcesWithCallback invokes the gwlb.ListTagResources API asynchronously

func (*Client) ListTagResourcesWithChan 

func (client *Client) ListTagResourcesWithChan(request *ListTagResourcesRequest) (<-chan *ListTagResourcesResponse, <-chan error)

ListTagResourcesWithChan invokes the gwlb.ListTagResources API asynchronously

func (*Client) MoveResourceGroup 

func (client *Client) MoveResourceGroup(request *MoveResourceGroupRequest) (response *MoveResourceGroupResponse, err error)

MoveResourceGroup invokes the gwlb.MoveResourceGroup API synchronously

func (*Client) MoveResourceGroupWithCallback 

func (client *Client) MoveResourceGroupWithCallback(request *MoveResourceGroupRequest, callback func(response *MoveResourceGroupResponse, err error)) <-chan int

MoveResourceGroupWithCallback invokes the gwlb.MoveResourceGroup API asynchronously

func (*Client) MoveResourceGroupWithChan 

func (client *Client) MoveResourceGroupWithChan(request *MoveResourceGroupRequest) (<-chan *MoveResourceGroupResponse, <-chan error)

MoveResourceGroupWithChan invokes the gwlb.MoveResourceGroup API asynchronously

func (*Client) RemoveServersFromServerGroup 

func (client *Client) RemoveServersFromServerGroup(request *RemoveServersFromServerGroupRequest) (response *RemoveServersFromServerGroupResponse, err error)

RemoveServersFromServerGroup invokes the gwlb.RemoveServersFromServerGroup API synchronously

func (*Client) RemoveServersFromServerGroupWithCallback 

func (client *Client) RemoveServersFromServerGroupWithCallback(request *RemoveServersFromServerGroupRequest, callback func(response *RemoveServersFromServerGroupResponse, err error)) <-chan int

RemoveServersFromServerGroupWithCallback invokes the gwlb.RemoveServersFromServerGroup API asynchronously

func (*Client) RemoveServersFromServerGroupWithChan 

func (client *Client) RemoveServersFromServerGroupWithChan(request *RemoveServersFromServerGroupRequest) (<-chan *RemoveServersFromServerGroupResponse, <-chan error)

RemoveServersFromServerGroupWithChan invokes the gwlb.RemoveServersFromServerGroup API asynchronously

func (*Client) TagResources 

func (client *Client) TagResources(request *TagResourcesRequest) (response *TagResourcesResponse, err error)

TagResources invokes the gwlb.TagResources API synchronously

func (*Client) TagResourcesWithCallback 

func (client *Client) TagResourcesWithCallback(request *TagResourcesRequest, callback func(response *TagResourcesResponse, err error)) <-chan int

TagResourcesWithCallback invokes the gwlb.TagResources API asynchronously

func (*Client) TagResourcesWithChan 

func (client *Client) TagResourcesWithChan(request *TagResourcesRequest) (<-chan *TagResourcesResponse, <-chan error)

TagResourcesWithChan invokes the gwlb.TagResources API asynchronously

func (*Client) UntagResources 

func (client *Client) UntagResources(request *UntagResourcesRequest) (response *UntagResourcesResponse, err error)

UntagResources invokes the gwlb.UntagResources API synchronously

func (*Client) UntagResourcesWithCallback 

func (client *Client) UntagResourcesWithCallback(request *UntagResourcesRequest, callback func(response *UntagResourcesResponse, err error)) <-chan int

UntagResourcesWithCallback invokes the gwlb.UntagResources API asynchronously

func (*Client) UntagResourcesWithChan 

func (client *Client) UntagResourcesWithChan(request *UntagResourcesRequest) (<-chan *UntagResourcesResponse, <-chan error)

UntagResourcesWithChan invokes the gwlb.UntagResources API asynchronously

func (*Client) UpdateListenerAttribute 

func (client *Client) UpdateListenerAttribute(request *UpdateListenerAttributeRequest) (response *UpdateListenerAttributeResponse, err error)

UpdateListenerAttribute invokes the gwlb.UpdateListenerAttribute API synchronously

func (*Client) UpdateListenerAttributeWithCallback 

func (client *Client) UpdateListenerAttributeWithCallback(request *UpdateListenerAttributeRequest, callback func(response *UpdateListenerAttributeResponse, err error)) <-chan int

UpdateListenerAttributeWithCallback invokes the gwlb.UpdateListenerAttribute API asynchronously

func (*Client) UpdateListenerAttributeWithChan 

func (client *Client) UpdateListenerAttributeWithChan(request *UpdateListenerAttributeRequest) (<-chan *UpdateListenerAttributeResponse, <-chan error)

UpdateListenerAttributeWithChan invokes the gwlb.UpdateListenerAttribute API asynchronously

func (*Client) UpdateLoadBalancerAttribute 

func (client *Client) UpdateLoadBalancerAttribute(request *UpdateLoadBalancerAttributeRequest) (response *UpdateLoadBalancerAttributeResponse, err error)

UpdateLoadBalancerAttribute invokes the gwlb.UpdateLoadBalancerAttribute API synchronously

func (*Client) UpdateLoadBalancerAttributeWithCallback 

func (client *Client) UpdateLoadBalancerAttributeWithCallback(request *UpdateLoadBalancerAttributeRequest, callback func(response *UpdateLoadBalancerAttributeResponse, err error)) <-chan int

UpdateLoadBalancerAttributeWithCallback invokes the gwlb.UpdateLoadBalancerAttribute API asynchronously

func (*Client) UpdateLoadBalancerAttributeWithChan 

func (client *Client) UpdateLoadBalancerAttributeWithChan(request *UpdateLoadBalancerAttributeRequest) (<-chan *UpdateLoadBalancerAttributeResponse, <-chan error)

UpdateLoadBalancerAttributeWithChan invokes the gwlb.UpdateLoadBalancerAttribute API asynchronously

func (*Client) UpdateLoadBalancerZones 

func (client *Client) UpdateLoadBalancerZones(request *UpdateLoadBalancerZonesRequest) (response *UpdateLoadBalancerZonesResponse, err error)

UpdateLoadBalancerZones invokes the gwlb.UpdateLoadBalancerZones API synchronously

func (*Client) UpdateLoadBalancerZonesWithCallback 

func (client *Client) UpdateLoadBalancerZonesWithCallback(request *UpdateLoadBalancerZonesRequest, callback func(response *UpdateLoadBalancerZonesResponse, err error)) <-chan int

UpdateLoadBalancerZonesWithCallback invokes the gwlb.UpdateLoadBalancerZones API asynchronously

func (*Client) UpdateLoadBalancerZonesWithChan 

func (client *Client) UpdateLoadBalancerZonesWithChan(request *UpdateLoadBalancerZonesRequest) (<-chan *UpdateLoadBalancerZonesResponse, <-chan error)

UpdateLoadBalancerZonesWithChan invokes the gwlb.UpdateLoadBalancerZones API asynchronously

func (*Client) UpdateServerGroupAttribute 

func (client *Client) UpdateServerGroupAttribute(request *UpdateServerGroupAttributeRequest) (response *UpdateServerGroupAttributeResponse, err error)

UpdateServerGroupAttribute invokes the gwlb.UpdateServerGroupAttribute API synchronously

func (*Client) UpdateServerGroupAttributeWithCallback 

func (client *Client) UpdateServerGroupAttributeWithCallback(request *UpdateServerGroupAttributeRequest, callback func(response *UpdateServerGroupAttributeResponse, err error)) <-chan int

UpdateServerGroupAttributeWithCallback invokes the gwlb.UpdateServerGroupAttribute API asynchronously

func (*Client) UpdateServerGroupAttributeWithChan 

func (client *Client) UpdateServerGroupAttributeWithChan(request *UpdateServerGroupAttributeRequest) (<-chan *UpdateServerGroupAttributeResponse, <-chan error)

UpdateServerGroupAttributeWithChan invokes the gwlb.UpdateServerGroupAttribute API asynchronously

type ConnectionDrainConfig 

type ConnectionDrainConfig struct {
	ConnectionDrainEnabled bool `json:"ConnectionDrainEnabled" xml:"ConnectionDrainEnabled"`
	ConnectionDrainTimeout int  `json:"ConnectionDrainTimeout" xml:"ConnectionDrainTimeout"`
}

ConnectionDrainConfig is a nested struct in gwlb response

type CreateListenerRequest 

type CreateListenerRequest struct {
	*requests.RpcRequest
	ClientToken         string               `position:"Body" name:"ClientToken"`
	ServerGroupId       string               `position:"Body" name:"ServerGroupId"`
	Tag                 *[]CreateListenerTag `position:"Body" name:"Tag"  type:"Repeated"`
	DryRun              requests.Boolean     `position:"Body" name:"DryRun"`
	LoadBalancerId      string               `position:"Body" name:"LoadBalancerId"`
	ListenerDescription string               `position:"Body" name:"ListenerDescription"`
}

CreateListenerRequest is the request struct for api CreateListener

func CreateCreateListenerRequest 

func CreateCreateListenerRequest() (request *CreateListenerRequest)

CreateCreateListenerRequest creates a request to invoke CreateListener API

type CreateListenerResponse 

type CreateListenerResponse struct {
	*responses.BaseResponse
	ListenerId string `json:"ListenerId" xml:"ListenerId"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
}

CreateListenerResponse is the response struct for api CreateListener

func CreateCreateListenerResponse 

func CreateCreateListenerResponse() (response *CreateListenerResponse)

CreateCreateListenerResponse creates a response to parse from CreateListener response

type CreateListenerTag 

type CreateListenerTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

CreateListenerTag is a repeated param struct in CreateListenerRequest

type CreateLoadBalancerRequest 

type CreateLoadBalancerRequest struct {
	*requests.RpcRequest
	CrossZoneEnabled requests.Boolean                  `position:"Body" name:"CrossZoneEnabled"`
	ClientToken      string                            `position:"Body" name:"ClientToken"`
	AddressIpVersion string                            `position:"Body" name:"AddressIpVersion"`
	ResourceGroupId  string                            `position:"Body" name:"ResourceGroupId"`
	LoadBalancerName string                            `position:"Body" name:"LoadBalancerName"`
	Tag              *[]CreateLoadBalancerTag          `position:"Body" name:"Tag"  type:"Repeated"`
	DryRun           requests.Boolean                  `position:"Body" name:"DryRun"`
	ZoneMappings     *[]CreateLoadBalancerZoneMappings `position:"Body" name:"ZoneMappings"  type:"Repeated"`
	VpcId            string                            `position:"Body" name:"VpcId"`
}

CreateLoadBalancerRequest is the request struct for api CreateLoadBalancer

func CreateCreateLoadBalancerRequest 

func CreateCreateLoadBalancerRequest() (request *CreateLoadBalancerRequest)

CreateCreateLoadBalancerRequest creates a request to invoke CreateLoadBalancer API

type CreateLoadBalancerResponse 

type CreateLoadBalancerResponse struct {
	*responses.BaseResponse
	LoadBalancerId string `json:"LoadBalancerId" xml:"LoadBalancerId"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
}

CreateLoadBalancerResponse is the response struct for api CreateLoadBalancer

func CreateCreateLoadBalancerResponse 

func CreateCreateLoadBalancerResponse() (response *CreateLoadBalancerResponse)

CreateCreateLoadBalancerResponse creates a response to parse from CreateLoadBalancer response

type CreateLoadBalancerTag 

type CreateLoadBalancerTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

CreateLoadBalancerTag is a repeated param struct in CreateLoadBalancerRequest

type CreateLoadBalancerZoneMappings 

type CreateLoadBalancerZoneMappings struct {
	VSwitchId string `name:"VSwitchId"`
	ZoneId    string `name:"ZoneId"`
}

CreateLoadBalancerZoneMappings is a repeated param struct in CreateLoadBalancerRequest

type CreateServerGroupConnectionDrainConfig 

type CreateServerGroupConnectionDrainConfig struct {
	ConnectionDrainEnabled string `name:"ConnectionDrainEnabled"`
	ConnectionDrainTimeout string `name:"ConnectionDrainTimeout"`
}

CreateServerGroupConnectionDrainConfig is a repeated param struct in CreateServerGroupRequest

type CreateServerGroupHealthCheckConfig 

type CreateServerGroupHealthCheckConfig struct {
	HealthCheckConnectPort    string    `name:"HealthCheckConnectPort"`
	HealthCheckConnectTimeout string    `name:"HealthCheckConnectTimeout"`
	HealthCheckDomain         string    `name:"HealthCheckDomain"`
	HealthCheckEnabled        string    `name:"HealthCheckEnabled"`
	HealthCheckHttpCode       *[]string `name:"HealthCheckHttpCode" type:"Repeated"`
	HealthCheckInterval       string    `name:"HealthCheckInterval"`
	HealthCheckPath           string    `name:"HealthCheckPath"`
	HealthCheckProtocol       string    `name:"HealthCheckProtocol"`
	HealthyThreshold          string    `name:"HealthyThreshold"`
	UnhealthyThreshold        string    `name:"UnhealthyThreshold"`
}

CreateServerGroupHealthCheckConfig is a repeated param struct in CreateServerGroupRequest

type CreateServerGroupRequest 

type CreateServerGroupRequest struct {
	*requests.RpcRequest
	ServerGroupName       string                                 `position:"Body" name:"ServerGroupName"`
	ClientToken           string                                 `position:"Body" name:"ClientToken"`
	HealthCheckConfig     CreateServerGroupHealthCheckConfig     `position:"Body" name:"HealthCheckConfig"  type:"Struct"`
	Scheduler             string                                 `position:"Body" name:"Scheduler"`
	ResourceGroupId       string                                 `position:"Body" name:"ResourceGroupId"`
	Protocol              string                                 `position:"Body" name:"Protocol"`
	Tag                   *[]CreateServerGroupTag                `position:"Body" name:"Tag"  type:"Repeated"`
	DryRun                requests.Boolean                       `position:"Body" name:"DryRun"`
	ConnectionDrainConfig CreateServerGroupConnectionDrainConfig `position:"Body" name:"ConnectionDrainConfig"  type:"Struct"`
	ServerGroupType       string                                 `position:"Body" name:"ServerGroupType"`
	VpcId                 string                                 `position:"Body" name:"VpcId"`
}

CreateServerGroupRequest is the request struct for api CreateServerGroup

func CreateCreateServerGroupRequest 

func CreateCreateServerGroupRequest() (request *CreateServerGroupRequest)

CreateCreateServerGroupRequest creates a request to invoke CreateServerGroup API

type CreateServerGroupResponse 

type CreateServerGroupResponse struct {
	*responses.BaseResponse
	RequestId     string `json:"RequestId" xml:"RequestId"`
	ServerGroupId string `json:"ServerGroupId" xml:"ServerGroupId"`
}

CreateServerGroupResponse is the response struct for api CreateServerGroup

func CreateCreateServerGroupResponse 

func CreateCreateServerGroupResponse() (response *CreateServerGroupResponse)

CreateCreateServerGroupResponse creates a response to parse from CreateServerGroup response

type CreateServerGroupTag 

type CreateServerGroupTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

CreateServerGroupTag is a repeated param struct in CreateServerGroupRequest

type Data 

type Data struct {
	LoadBalancerStatus         string         `json:"LoadBalancerStatus" xml:"LoadBalancerStatus"`
	LocalName                  string         `json:"LocalName" xml:"LocalName"`
	CreateTime                 string         `json:"CreateTime" xml:"CreateTime"`
	LoadBalancerId             string         `json:"LoadBalancerId" xml:"LoadBalancerId"`
	CrossZoneEnabled           bool           `json:"CrossZoneEnabled" xml:"CrossZoneEnabled"`
	RegionId                   string         `json:"RegionId" xml:"RegionId"`
	ZoneId                     string         `json:"ZoneId" xml:"ZoneId"`
	ResourceGroupId            string         `json:"ResourceGroupId" xml:"ResourceGroupId"`
	LoadBalancerName           string         `json:"LoadBalancerName" xml:"LoadBalancerName"`
	LoadBalancerBusinessStatus string         `json:"LoadBalancerBusinessStatus" xml:"LoadBalancerBusinessStatus"`
	VpcId                      string         `json:"VpcId" xml:"VpcId"`
	RegionEndpoint             string         `json:"RegionEndpoint" xml:"RegionEndpoint"`
	AddressIpVersion           string         `json:"AddressIpVersion" xml:"AddressIpVersion"`
	ZoneMappings               []ZoneEniModel `json:"ZoneMappings" xml:"ZoneMappings"`
	Tags                       []TagModel     `json:"Tags" xml:"Tags"`
}

Data is a nested struct in gwlb response

type DeleteListenerRequest 

type DeleteListenerRequest struct {
	*requests.RpcRequest
	ClientToken string           `position:"Body" name:"ClientToken"`
	ListenerId  string           `position:"Body" name:"ListenerId"`
	DryRun      requests.Boolean `position:"Body" name:"DryRun"`
}

DeleteListenerRequest is the request struct for api DeleteListener

func CreateDeleteListenerRequest 

func CreateDeleteListenerRequest() (request *DeleteListenerRequest)

CreateDeleteListenerRequest creates a request to invoke DeleteListener API

type DeleteListenerResponse 

type DeleteListenerResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteListenerResponse is the response struct for api DeleteListener

func CreateDeleteListenerResponse 

func CreateDeleteListenerResponse() (response *DeleteListenerResponse)

CreateDeleteListenerResponse creates a response to parse from DeleteListener response

type DeleteLoadBalancerRequest 

type DeleteLoadBalancerRequest struct {
	*requests.RpcRequest
	ClientToken    string           `position:"Body" name:"ClientToken"`
	DryRun         requests.Boolean `position:"Body" name:"DryRun"`
	LoadBalancerId string           `position:"Body" name:"LoadBalancerId"`
}

DeleteLoadBalancerRequest is the request struct for api DeleteLoadBalancer

func CreateDeleteLoadBalancerRequest 

func CreateDeleteLoadBalancerRequest() (request *DeleteLoadBalancerRequest)

CreateDeleteLoadBalancerRequest creates a request to invoke DeleteLoadBalancer API

type DeleteLoadBalancerResponse 

type DeleteLoadBalancerResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteLoadBalancerResponse is the response struct for api DeleteLoadBalancer

func CreateDeleteLoadBalancerResponse 

func CreateDeleteLoadBalancerResponse() (response *DeleteLoadBalancerResponse)

CreateDeleteLoadBalancerResponse creates a response to parse from DeleteLoadBalancer response

type DeleteServerGroupRequest 

type DeleteServerGroupRequest struct {
	*requests.RpcRequest
	ClientToken   string           `position:"Body" name:"ClientToken"`
	ServerGroupId string           `position:"Body" name:"ServerGroupId"`
	DryRun        requests.Boolean `position:"Body" name:"DryRun"`
}

DeleteServerGroupRequest is the request struct for api DeleteServerGroup

func CreateDeleteServerGroupRequest 

func CreateDeleteServerGroupRequest() (request *DeleteServerGroupRequest)

CreateDeleteServerGroupRequest creates a request to invoke DeleteServerGroup API

type DeleteServerGroupResponse 

type DeleteServerGroupResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteServerGroupResponse is the response struct for api DeleteServerGroup

func CreateDeleteServerGroupResponse 

func CreateDeleteServerGroupResponse() (response *DeleteServerGroupResponse)

CreateDeleteServerGroupResponse creates a response to parse from DeleteServerGroup response

type DescribeRegionsRequest 

type DescribeRegionsRequest struct {
	*requests.RpcRequest
	AcceptLanguage string `position:"Body" name:"AcceptLanguage"`
}

DescribeRegionsRequest is the request struct for api DescribeRegions

func CreateDescribeRegionsRequest 

func CreateDescribeRegionsRequest() (request *DescribeRegionsRequest)

CreateDescribeRegionsRequest creates a request to invoke DescribeRegions API

type DescribeRegionsResponse 

type DescribeRegionsResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Regions   []Data `json:"Regions" xml:"Regions"`
}

DescribeRegionsResponse is the response struct for api DescribeRegions

func CreateDescribeRegionsResponse 

func CreateDescribeRegionsResponse() (response *DescribeRegionsResponse)

CreateDescribeRegionsResponse creates a response to parse from DescribeRegions response

type DescribeZonesRequest 

type DescribeZonesRequest struct {
	*requests.RpcRequest
	AcceptLanguage string `position:"Body" name:"AcceptLanguage"`
}

DescribeZonesRequest is the request struct for api DescribeZones

func CreateDescribeZonesRequest 

func CreateDescribeZonesRequest() (request *DescribeZonesRequest)

CreateDescribeZonesRequest creates a request to invoke DescribeZones API

type DescribeZonesResponse 

type DescribeZonesResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Zones     []Data `json:"Zones" xml:"Zones"`
}

DescribeZonesResponse is the response struct for api DescribeZones

func CreateDescribeZonesResponse 

func CreateDescribeZonesResponse() (response *DescribeZonesResponse)

CreateDescribeZonesResponse creates a response to parse from DescribeZones response

type EniModels 

type EniModels struct {
	PrivateIpv4Address string `json:"PrivateIpv4Address" xml:"PrivateIpv4Address"`
	EniId              string `json:"EniId" xml:"EniId"`
}

EniModels is a nested struct in gwlb response

type GetListenerAttributeRequest 

type GetListenerAttributeRequest struct {
	*requests.RpcRequest
	ListenerId string `position:"Body" name:"ListenerId"`
}

GetListenerAttributeRequest is the request struct for api GetListenerAttribute

func CreateGetListenerAttributeRequest 

func CreateGetListenerAttributeRequest() (request *GetListenerAttributeRequest)

CreateGetListenerAttributeRequest creates a request to invoke GetListenerAttribute API

type GetListenerAttributeResponse 

type GetListenerAttributeResponse struct {
	*responses.BaseResponse
	ListenerDescription string     `json:"ListenerDescription" xml:"ListenerDescription"`
	ListenerId          string     `json:"ListenerId" xml:"ListenerId"`
	ListenerStatus      string     `json:"ListenerStatus" xml:"ListenerStatus"`
	LoadBalancerId      string     `json:"LoadBalancerId" xml:"LoadBalancerId"`
	RegionId            string     `json:"RegionId" xml:"RegionId"`
	RequestId           string     `json:"RequestId" xml:"RequestId"`
	ServerGroupId       string     `json:"ServerGroupId" xml:"ServerGroupId"`
	Tags                []TagModel `json:"Tags" xml:"Tags"`
}

GetListenerAttributeResponse is the response struct for api GetListenerAttribute

func CreateGetListenerAttributeResponse 

func CreateGetListenerAttributeResponse() (response *GetListenerAttributeResponse)

CreateGetListenerAttributeResponse creates a response to parse from GetListenerAttribute response

type GetListenerHealthStatusFilter 

type GetListenerHealthStatusFilter struct {
	Name   string    `name:"Name"`
	Values *[]string `name:"Values" type:"Repeated"`
}

GetListenerHealthStatusFilter is a repeated param struct in GetListenerHealthStatusRequest

type GetListenerHealthStatusRequest 

type GetListenerHealthStatusRequest struct {
	*requests.RpcRequest
	Skip       requests.Integer                 `position:"Body" name:"Skip"`
	ListenerId string                           `position:"Body" name:"ListenerId"`
	NextToken  string                           `position:"Body" name:"NextToken"`
	Filter     *[]GetListenerHealthStatusFilter `position:"Body" name:"Filter"  type:"Repeated"`
	MaxResults requests.Integer                 `position:"Body" name:"MaxResults"`
}

GetListenerHealthStatusRequest is the request struct for api GetListenerHealthStatus

func CreateGetListenerHealthStatusRequest 

func CreateGetListenerHealthStatusRequest() (request *GetListenerHealthStatusRequest)

CreateGetListenerHealthStatusRequest creates a request to invoke GetListenerHealthStatus API

type GetListenerHealthStatusResponse 

type GetListenerHealthStatusResponse struct {
	*responses.BaseResponse
	MaxResults           int                        `json:"MaxResults" xml:"MaxResults"`
	NextToken            string                     `json:"NextToken" xml:"NextToken"`
	RequestId            string                     `json:"RequestId" xml:"RequestId"`
	TotalCount           int                        `json:"TotalCount" xml:"TotalCount"`
	ListenerHealthStatus []ListenerHealthStatusItem `json:"ListenerHealthStatus" xml:"ListenerHealthStatus"`
}

GetListenerHealthStatusResponse is the response struct for api GetListenerHealthStatus

func CreateGetListenerHealthStatusResponse 

func CreateGetListenerHealthStatusResponse() (response *GetListenerHealthStatusResponse)

CreateGetListenerHealthStatusResponse creates a response to parse from GetListenerHealthStatus response

type GetLoadBalancerAttributeRequest 

type GetLoadBalancerAttributeRequest struct {
	*requests.RpcRequest
	LoadBalancerId string `position:"Body" name:"LoadBalancerId"`
}

GetLoadBalancerAttributeRequest is the request struct for api GetLoadBalancerAttribute

func CreateGetLoadBalancerAttributeRequest 

func CreateGetLoadBalancerAttributeRequest() (request *GetLoadBalancerAttributeRequest)

CreateGetLoadBalancerAttributeRequest creates a request to invoke GetLoadBalancerAttribute API

type GetLoadBalancerAttributeResponse 

type GetLoadBalancerAttributeResponse struct {
	*responses.BaseResponse
	AddressIpVersion           string         `json:"AddressIpVersion" xml:"AddressIpVersion"`
	CreateTime                 string         `json:"CreateTime" xml:"CreateTime"`
	CrossZoneEnabled           bool           `json:"CrossZoneEnabled" xml:"CrossZoneEnabled"`
	LoadBalancerBusinessStatus string         `json:"LoadBalancerBusinessStatus" xml:"LoadBalancerBusinessStatus"`
	LoadBalancerId             string         `json:"LoadBalancerId" xml:"LoadBalancerId"`
	LoadBalancerName           string         `json:"LoadBalancerName" xml:"LoadBalancerName"`
	LoadBalancerStatus         string         `json:"LoadBalancerStatus" xml:"LoadBalancerStatus"`
	RequestId                  string         `json:"RequestId" xml:"RequestId"`
	ResourceGroupId            string         `json:"ResourceGroupId" xml:"ResourceGroupId"`
	VpcId                      string         `json:"VpcId" xml:"VpcId"`
	Tags                       []TagModel     `json:"Tags" xml:"Tags"`
	ZoneMappings               []ZoneEniModel `json:"ZoneMappings" xml:"ZoneMappings"`
}

GetLoadBalancerAttributeResponse is the response struct for api GetLoadBalancerAttribute

func CreateGetLoadBalancerAttributeResponse 

func CreateGetLoadBalancerAttributeResponse() (response *GetLoadBalancerAttributeResponse)

CreateGetLoadBalancerAttributeResponse creates a response to parse from GetLoadBalancerAttribute response

type HealthCheckConfig 

type HealthCheckConfig struct {
	HealthCheckConnectPort    int      `json:"HealthCheckConnectPort" xml:"HealthCheckConnectPort"`
	HealthCheckConnectTimeout int      `json:"HealthCheckConnectTimeout" xml:"HealthCheckConnectTimeout"`
	HealthCheckDomain         string   `json:"HealthCheckDomain" xml:"HealthCheckDomain"`
	HealthCheckEnabled        bool     `json:"HealthCheckEnabled" xml:"HealthCheckEnabled"`
	HealthCheckInterval       int      `json:"HealthCheckInterval" xml:"HealthCheckInterval"`
	HealthCheckPath           string   `json:"HealthCheckPath" xml:"HealthCheckPath"`
	HealthCheckProtocol       string   `json:"HealthCheckProtocol" xml:"HealthCheckProtocol"`
	HealthyThreshold          int      `json:"HealthyThreshold" xml:"HealthyThreshold"`
	UnhealthyThreshold        int      `json:"UnhealthyThreshold" xml:"UnhealthyThreshold"`
	HealthCheckHttpCode       []string `json:"HealthCheckHttpCode" xml:"HealthCheckHttpCode"`
}

HealthCheckConfig is a nested struct in gwlb response

type HealthCheckHttpCode 

type HealthCheckHttpCode struct {
	HealthCheckHttpCode []string `json:"HealthCheckHttpCode" xml:"HealthCheckHttpCode"`
}

HealthCheckHttpCode is a nested struct in gwlb response

type ListListenersRequest 

type ListListenersRequest struct {
	*requests.RpcRequest
	LoadBalancerIds *[]string           `position:"Body" name:"LoadBalancerIds"  type:"Repeated"`
	Skip            requests.Integer    `position:"Body" name:"Skip"`
	NextToken       string              `position:"Body" name:"NextToken"`
	Tag             *[]ListListenersTag `position:"Body" name:"Tag"  type:"Repeated"`
	ListenerIds     *[]string           `position:"Body" name:"ListenerIds"  type:"Repeated"`
	MaxResults      requests.Integer    `position:"Body" name:"MaxResults"`
}

ListListenersRequest is the request struct for api ListListeners

func CreateListListenersRequest 

func CreateListListenersRequest() (request *ListListenersRequest)

CreateListListenersRequest creates a request to invoke ListListeners API

type ListListenersResponse 

type ListListenersResponse struct {
	*responses.BaseResponse
	MaxResults int        `json:"MaxResults" xml:"MaxResults"`
	NextToken  string     `json:"NextToken" xml:"NextToken"`
	RequestId  string     `json:"RequestId" xml:"RequestId"`
	TotalCount int        `json:"TotalCount" xml:"TotalCount"`
	Listeners  []Listener `json:"Listeners" xml:"Listeners"`
}

ListListenersResponse is the response struct for api ListListeners

func CreateListListenersResponse 

func CreateListListenersResponse() (response *ListListenersResponse)

CreateListListenersResponse creates a response to parse from ListListeners response

type ListListenersTag 

type ListListenersTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

ListListenersTag is a repeated param struct in ListListenersRequest

type ListLoadBalancersRequest 

type ListLoadBalancersRequest struct {
	*requests.RpcRequest
	LoadBalancerNames          *[]string               `position:"Body" name:"LoadBalancerNames"  type:"Repeated"`
	LoadBalancerIds            *[]string               `position:"Body" name:"LoadBalancerIds"  type:"Repeated"`
	Skip                       requests.Integer        `position:"Body" name:"Skip"`
	AddressIpVersion           string                  `position:"Body" name:"AddressIpVersion"`
	ResourceGroupId            string                  `position:"Body" name:"ResourceGroupId"`
	ZoneIds                    *[]string               `position:"Body" name:"ZoneIds"  type:"Repeated"`
	NextToken                  string                  `position:"Body" name:"NextToken"`
	VpcIds                     *[]string               `position:"Body" name:"VpcIds"  type:"Repeated"`
	Tag                        *[]ListLoadBalancersTag `position:"Body" name:"Tag"  type:"Repeated"`
	LoadBalancerBusinessStatus string                  `position:"Body" name:"LoadBalancerBusinessStatus"`
	LoadBalancerStatus         string                  `position:"Body" name:"LoadBalancerStatus"`
	MaxResults                 requests.Integer        `position:"Body" name:"MaxResults"`
}

ListLoadBalancersRequest is the request struct for api ListLoadBalancers

func CreateListLoadBalancersRequest 

func CreateListLoadBalancersRequest() (request *ListLoadBalancersRequest)

CreateListLoadBalancersRequest creates a request to invoke ListLoadBalancers API

type ListLoadBalancersResponse 

type ListLoadBalancersResponse struct {
	*responses.BaseResponse
	MaxResults    int    `json:"MaxResults" xml:"MaxResults"`
	NextToken     string `json:"NextToken" xml:"NextToken"`
	RequestId     string `json:"RequestId" xml:"RequestId"`
	TotalCount    int    `json:"TotalCount" xml:"TotalCount"`
	LoadBalancers []Data `json:"LoadBalancers" xml:"LoadBalancers"`
}

ListLoadBalancersResponse is the response struct for api ListLoadBalancers

func CreateListLoadBalancersResponse 

func CreateListLoadBalancersResponse() (response *ListLoadBalancersResponse)

CreateListLoadBalancersResponse creates a response to parse from ListLoadBalancers response

type ListLoadBalancersTag 

type ListLoadBalancersTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

ListLoadBalancersTag is a repeated param struct in ListLoadBalancersRequest

type ListServerGroupServersRequest 

type ListServerGroupServersRequest struct {
	*requests.RpcRequest
	Skip          requests.Integer `position:"Body" name:"Skip"`
	ServerGroupId string           `position:"Body" name:"ServerGroupId"`
	NextToken     string           `position:"Body" name:"NextToken"`
	ServerIds     *[]string        `position:"Body" name:"ServerIds"  type:"Repeated"`
	ServerIps     *[]string        `position:"Body" name:"ServerIps"  type:"Repeated"`
	MaxResults    requests.Integer `position:"Body" name:"MaxResults"`
}

ListServerGroupServersRequest is the request struct for api ListServerGroupServers

func CreateListServerGroupServersRequest 

func CreateListServerGroupServersRequest() (request *ListServerGroupServersRequest)

CreateListServerGroupServersRequest creates a request to invoke ListServerGroupServers API

type ListServerGroupServersResponse 

type ListServerGroupServersResponse struct {
	*responses.BaseResponse
	MaxResults int      `json:"MaxResults" xml:"MaxResults"`
	NextToken  string   `json:"NextToken" xml:"NextToken"`
	RequestId  string   `json:"RequestId" xml:"RequestId"`
	TotalCount int      `json:"TotalCount" xml:"TotalCount"`
	Servers    []Server `json:"Servers" xml:"Servers"`
}

ListServerGroupServersResponse is the response struct for api ListServerGroupServers

func CreateListServerGroupServersResponse 

func CreateListServerGroupServersResponse() (response *ListServerGroupServersResponse)

CreateListServerGroupServersResponse creates a response to parse from ListServerGroupServers response

type ListServerGroupsRequest 

type ListServerGroupsRequest struct {
	*requests.RpcRequest
	ServerGroupNames *[]string              `position:"Body" name:"ServerGroupNames"  type:"Repeated"`
	Skip             requests.Integer       `position:"Body" name:"Skip"`
	ResourceGroupId  string                 `position:"Body" name:"ResourceGroupId"`
	NextToken        string                 `position:"Body" name:"NextToken"`
	Tag              *[]ListServerGroupsTag `position:"Body" name:"Tag"  type:"Repeated"`
	ServerGroupIds   *[]string              `position:"Body" name:"ServerGroupIds"  type:"Repeated"`
	ServerGroupType  string                 `position:"Body" name:"ServerGroupType"`
	VpcId            string                 `position:"Body" name:"VpcId"`
	MaxResults       requests.Integer       `position:"Body" name:"MaxResults"`
}

ListServerGroupsRequest is the request struct for api ListServerGroups

func CreateListServerGroupsRequest 

func CreateListServerGroupsRequest() (request *ListServerGroupsRequest)

CreateListServerGroupsRequest creates a request to invoke ListServerGroups API

type ListServerGroupsResponse 

type ListServerGroupsResponse struct {
	*responses.BaseResponse
	MaxResults   int           `json:"MaxResults" xml:"MaxResults"`
	NextToken    string        `json:"NextToken" xml:"NextToken"`
	RequestId    string        `json:"RequestId" xml:"RequestId"`
	TotalCount   int           `json:"TotalCount" xml:"TotalCount"`
	ServerGroups []ServerGroup `json:"ServerGroups" xml:"ServerGroups"`
}

ListServerGroupsResponse is the response struct for api ListServerGroups

func CreateListServerGroupsResponse 

func CreateListServerGroupsResponse() (response *ListServerGroupsResponse)

CreateListServerGroupsResponse creates a response to parse from ListServerGroups response

type ListServerGroupsTag 

type ListServerGroupsTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

ListServerGroupsTag is a repeated param struct in ListServerGroupsRequest

type ListTagResourcesRequest 

type ListTagResourcesRequest struct {
	*requests.RpcRequest
	NextToken    string                 `position:"Body" name:"NextToken"`
	Tag          *[]ListTagResourcesTag `position:"Body" name:"Tag"  type:"Repeated"`
	ResourceId   *[]string              `position:"Body" name:"ResourceId"  type:"Repeated"`
	ResourceType string                 `position:"Body" name:"ResourceType"`
	MaxResults   requests.Integer       `position:"Body" name:"MaxResults"`
}

ListTagResourcesRequest is the request struct for api ListTagResources

func CreateListTagResourcesRequest 

func CreateListTagResourcesRequest() (request *ListTagResourcesRequest)

CreateListTagResourcesRequest creates a request to invoke ListTagResources API

type ListTagResourcesResponse 

type ListTagResourcesResponse struct {
	*responses.BaseResponse
	NextToken    string        `json:"NextToken" xml:"NextToken"`
	RequestId    string        `json:"RequestId" xml:"RequestId"`
	TagResources []TagResource `json:"TagResources" xml:"TagResources"`
}

ListTagResourcesResponse is the response struct for api ListTagResources

func CreateListTagResourcesResponse 

func CreateListTagResourcesResponse() (response *ListTagResourcesResponse)

CreateListTagResourcesResponse creates a response to parse from ListTagResources response

type ListTagResourcesTag 

type ListTagResourcesTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

ListTagResourcesTag is a repeated param struct in ListTagResourcesRequest

type Listener 

type Listener struct {
	ListenerDescription string     `json:"ListenerDescription" xml:"ListenerDescription"`
	ListenerId          string     `json:"ListenerId" xml:"ListenerId"`
	ListenerStatus      string     `json:"ListenerStatus" xml:"ListenerStatus"`
	LoadBalancerId      string     `json:"LoadBalancerId" xml:"LoadBalancerId"`
	ServerGroupId       string     `json:"ServerGroupId" xml:"ServerGroupId"`
	Tags                []TagModel `json:"Tags" xml:"Tags"`
}

Listener is a nested struct in gwlb response

type ListenerHealthStatus 

type ListenerHealthStatus struct {
	ListenerHealthStatusItem []ListenerHealthStatusItem `json:"listenerHealthStatus" xml:"listenerHealthStatus"`
}

ListenerHealthStatus is a nested struct in gwlb response

type ListenerHealthStatusItem 

type ListenerHealthStatusItem struct {
	ListenerId       string            `json:"ListenerId" xml:"ListenerId"`
	ServerGroupInfos []ServerGroupInfo `json:"ServerGroupInfos" xml:"ServerGroupInfos"`
}

ListenerHealthStatusItem is a nested struct in gwlb response

type Listeners 

type Listeners struct {
	Listener []Listener `json:"listener" xml:"listener"`
}

Listeners is a nested struct in gwlb response

type LoadBalancerAddressesInGetLoadBalancerAttribute 

type LoadBalancerAddressesInGetLoadBalancerAttribute struct {
	EniModels []EniModels `json:"EniModels" xml:"EniModels"`
}

LoadBalancerAddressesInGetLoadBalancerAttribute is a nested struct in gwlb response

type LoadBalancerAddressesInListLoadBalancers 

type LoadBalancerAddressesInListLoadBalancers struct {
	EniModels []EniModels `json:"EniModels" xml:"EniModels"`
}

LoadBalancerAddressesInListLoadBalancers is a nested struct in gwlb response

type LoadBalancers 

type LoadBalancers struct {
	Data []Data `json:"Data" xml:"Data"`
}

LoadBalancers is a nested struct in gwlb response

type MoveResourceGroupRequest 

type MoveResourceGroupRequest struct {
	*requests.RpcRequest
	ClientToken        string           `position:"Body" name:"ClientToken"`
	ResourceId         string           `position:"Body" name:"ResourceId"`
	DryRun             requests.Boolean `position:"Body" name:"DryRun"`
	ResourceType       string           `position:"Body" name:"ResourceType"`
	NewResourceGroupId string           `position:"Body" name:"NewResourceGroupId"`
}

MoveResourceGroupRequest is the request struct for api MoveResourceGroup

func CreateMoveResourceGroupRequest 

func CreateMoveResourceGroupRequest() (request *MoveResourceGroupRequest)

CreateMoveResourceGroupRequest creates a request to invoke MoveResourceGroup API

type MoveResourceGroupResponse 

type MoveResourceGroupResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

MoveResourceGroupResponse is the response struct for api MoveResourceGroup

func CreateMoveResourceGroupResponse 

func CreateMoveResourceGroupResponse() (response *MoveResourceGroupResponse)

CreateMoveResourceGroupResponse creates a response to parse from MoveResourceGroup response

type Reason 

type Reason struct {
	ReasonCode string `json:"ReasonCode" xml:"ReasonCode"`
}

Reason is a nested struct in gwlb response

type Regions 

type Regions struct {
	Data []Data `json:"Data" xml:"Data"`
}

Regions is a nested struct in gwlb response

type RelatedLoadBalancerIds 

type RelatedLoadBalancerIds struct {
	LoadBalancerId []string `json:"LoadBalancerId" xml:"LoadBalancerId"`
}

RelatedLoadBalancerIds is a nested struct in gwlb response

type RemoveServersFromServerGroupRequest 

type RemoveServersFromServerGroupRequest struct {
	*requests.RpcRequest
	ClientToken   string                                 `position:"Body" name:"ClientToken"`
	ServerGroupId string                                 `position:"Body" name:"ServerGroupId"`
	Servers       *[]RemoveServersFromServerGroupServers `position:"Body" name:"Servers"  type:"Repeated"`
	DryRun        requests.Boolean                       `position:"Body" name:"DryRun"`
}

RemoveServersFromServerGroupRequest is the request struct for api RemoveServersFromServerGroup

func CreateRemoveServersFromServerGroupRequest 

func CreateRemoveServersFromServerGroupRequest() (request *RemoveServersFromServerGroupRequest)

CreateRemoveServersFromServerGroupRequest creates a request to invoke RemoveServersFromServerGroup API

type RemoveServersFromServerGroupResponse 

type RemoveServersFromServerGroupResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

RemoveServersFromServerGroupResponse is the response struct for api RemoveServersFromServerGroup

func CreateRemoveServersFromServerGroupResponse 

func CreateRemoveServersFromServerGroupResponse() (response *RemoveServersFromServerGroupResponse)

CreateRemoveServersFromServerGroupResponse creates a response to parse from RemoveServersFromServerGroup response

type RemoveServersFromServerGroupServers 

type RemoveServersFromServerGroupServers struct {
	Port       string `name:"Port"`
	ServerId   string `name:"ServerId"`
	ServerIp   string `name:"ServerIp"`
	ServerType string `name:"ServerType"`
}

RemoveServersFromServerGroupServers is a repeated param struct in RemoveServersFromServerGroupRequest

type Server 

type Server struct {
	Port          int    `json:"Port" xml:"Port"`
	ServerGroupId string `json:"ServerGroupId" xml:"ServerGroupId"`
	ServerIp      string `json:"ServerIp" xml:"ServerIp"`
	ServerId      string `json:"ServerId" xml:"ServerId"`
	Status        string `json:"Status" xml:"Status"`
	ServerType    string `json:"ServerType" xml:"ServerType"`
	Reason        Reason `json:"Reason" xml:"Reason"`
}

Server is a nested struct in gwlb response

type ServerGroup 

type ServerGroup struct {
	CreateTime             string                `json:"CreateTime" xml:"CreateTime"`
	Protocol               string                `json:"Protocol" xml:"Protocol"`
	ResourceGroupId        string                `json:"ResourceGroupId" xml:"ResourceGroupId"`
	Scheduler              string                `json:"Scheduler" xml:"Scheduler"`
	ServerCount            int                   `json:"ServerCount" xml:"ServerCount"`
	ServerGroupId          string                `json:"ServerGroupId" xml:"ServerGroupId"`
	ServerGroupName        string                `json:"ServerGroupName" xml:"ServerGroupName"`
	ServerGroupStatus      string                `json:"ServerGroupStatus" xml:"ServerGroupStatus"`
	ServerGroupType        string                `json:"ServerGroupType" xml:"ServerGroupType"`
	VpcId                  string                `json:"VpcId" xml:"VpcId"`
	RelatedLoadBalancerIds []string              `json:"RelatedLoadBalancerIds" xml:"RelatedLoadBalancerIds"`
	ConnectionDrainConfig  ConnectionDrainConfig `json:"ConnectionDrainConfig" xml:"ConnectionDrainConfig"`
	HealthCheckConfig      HealthCheckConfig     `json:"HealthCheckConfig" xml:"HealthCheckConfig"`
	Tags                   []TagModel            `json:"Tags" xml:"Tags"`
}

ServerGroup is a nested struct in gwlb response

type ServerGroupInfo 

type ServerGroupInfo struct {
	HealthCheckEnabled bool     `json:"HealthCheckEnabled" xml:"HealthCheckEnabled"`
	ServerGroupId      string   `json:"ServerGroupId" xml:"ServerGroupId"`
	Servers            []Server `json:"Servers" xml:"Servers"`
}

ServerGroupInfo is a nested struct in gwlb response

type ServerGroupInfos 

type ServerGroupInfos struct {
	ServerGroupInfo []ServerGroupInfo `json:"ServerGroupInfo" xml:"ServerGroupInfo"`
}

ServerGroupInfos is a nested struct in gwlb response

type ServerGroups 

type ServerGroups struct {
	ServerGroup []ServerGroup `json:"serverGroup" xml:"serverGroup"`
}

ServerGroups is a nested struct in gwlb response

type ServersInGetListenerHealthStatus 

type ServersInGetListenerHealthStatus struct {
	Server []Server `json:"server" xml:"server"`
}

ServersInGetListenerHealthStatus is a nested struct in gwlb response

type ServersInListServerGroupServers 

type ServersInListServerGroupServers struct {
	Server []Server `json:"Server" xml:"Server"`
}

ServersInListServerGroupServers is a nested struct in gwlb response

type TagModel 

type TagModel struct {
	Key   string `json:"Key" xml:"Key"`
	Value string `json:"Value" xml:"Value"`
}

TagModel is a nested struct in gwlb response

type TagResource 

type TagResource struct {
	ResourceId   string `json:"ResourceId" xml:"ResourceId"`
	ResourceType string `json:"ResourceType" xml:"ResourceType"`
	TagKey       string `json:"TagKey" xml:"TagKey"`
	TagValue     string `json:"TagValue" xml:"TagValue"`
}

TagResource is a nested struct in gwlb response

type TagResources 

type TagResources struct {
	TagResource []TagResource `json:"tagResource" xml:"tagResource"`
}

TagResources is a nested struct in gwlb response

type TagResourcesRequest 

type TagResourcesRequest struct {
	*requests.RpcRequest
	ClientToken  string             `position:"Body" name:"ClientToken"`
	Tag          *[]TagResourcesTag `position:"Body" name:"Tag"  type:"Repeated"`
	ResourceId   *[]string          `position:"Body" name:"ResourceId"  type:"Repeated"`
	DryRun       requests.Boolean   `position:"Body" name:"DryRun"`
	ResourceType string             `position:"Body" name:"ResourceType"`
}

TagResourcesRequest is the request struct for api TagResources

func CreateTagResourcesRequest 

func CreateTagResourcesRequest() (request *TagResourcesRequest)

CreateTagResourcesRequest creates a request to invoke TagResources API

type TagResourcesResponse 

type TagResourcesResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

TagResourcesResponse is the response struct for api TagResources

func CreateTagResourcesResponse 

func CreateTagResourcesResponse() (response *TagResourcesResponse)

CreateTagResourcesResponse creates a response to parse from TagResources response

type TagResourcesTag 

type TagResourcesTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

TagResourcesTag is a repeated param struct in TagResourcesRequest

type TagsInGetListenerAttribute 

type TagsInGetListenerAttribute struct {
	TagModel []TagModel `json:"TagModel" xml:"TagModel"`
}

TagsInGetListenerAttribute is a nested struct in gwlb response

type TagsInGetLoadBalancerAttribute 

type TagsInGetLoadBalancerAttribute struct {
	TagModel []TagModel `json:"TagModel" xml:"TagModel"`
}

TagsInGetLoadBalancerAttribute is a nested struct in gwlb response

type TagsInListListeners 

type TagsInListListeners struct {
	TagModel []TagModel `json:"TagModel" xml:"TagModel"`
}

TagsInListListeners is a nested struct in gwlb response

type TagsInListLoadBalancers 

type TagsInListLoadBalancers struct {
	TagModel []TagModel `json:"TagModel" xml:"TagModel"`
}

TagsInListLoadBalancers is a nested struct in gwlb response

type TagsInListServerGroups 

type TagsInListServerGroups struct {
	TagModel []TagModel `json:"TagModel" xml:"TagModel"`
}

TagsInListServerGroups is a nested struct in gwlb response

type UntagResourcesRequest 

type UntagResourcesRequest struct {
	*requests.RpcRequest
	ClientToken  string           `position:"Body" name:"ClientToken"`
	All          requests.Boolean `position:"Body" name:"All"`
	ResourceId   *[]string        `position:"Body" name:"ResourceId"  type:"Repeated"`
	DryRun       requests.Boolean `position:"Body" name:"DryRun"`
	ResourceType string           `position:"Body" name:"ResourceType"`
	TagKey       *[]string        `position:"Body" name:"TagKey"  type:"Repeated"`
}

UntagResourcesRequest is the request struct for api UntagResources

func CreateUntagResourcesRequest 

func CreateUntagResourcesRequest() (request *UntagResourcesRequest)

CreateUntagResourcesRequest creates a request to invoke UntagResources API

type UntagResourcesResponse 

type UntagResourcesResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UntagResourcesResponse is the response struct for api UntagResources

func CreateUntagResourcesResponse 

func CreateUntagResourcesResponse() (response *UntagResourcesResponse)

CreateUntagResourcesResponse creates a response to parse from UntagResources response

type UpdateListenerAttributeRequest 

type UpdateListenerAttributeRequest struct {
	*requests.RpcRequest
	ClientToken         string           `position:"Body" name:"ClientToken"`
	ServerGroupId       string           `position:"Body" name:"ServerGroupId"`
	ListenerId          string           `position:"Body" name:"ListenerId"`
	DryRun              requests.Boolean `position:"Body" name:"DryRun"`
	ListenerDescription string           `position:"Body" name:"ListenerDescription"`
}

UpdateListenerAttributeRequest is the request struct for api UpdateListenerAttribute

func CreateUpdateListenerAttributeRequest 

func CreateUpdateListenerAttributeRequest() (request *UpdateListenerAttributeRequest)

CreateUpdateListenerAttributeRequest creates a request to invoke UpdateListenerAttribute API

type UpdateListenerAttributeResponse 

type UpdateListenerAttributeResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateListenerAttributeResponse is the response struct for api UpdateListenerAttribute

func CreateUpdateListenerAttributeResponse 

func CreateUpdateListenerAttributeResponse() (response *UpdateListenerAttributeResponse)

CreateUpdateListenerAttributeResponse creates a response to parse from UpdateListenerAttribute response

type UpdateLoadBalancerAttributeRequest 

type UpdateLoadBalancerAttributeRequest struct {
	*requests.RpcRequest
	CrossZoneEnabled requests.Boolean `position:"Body" name:"CrossZoneEnabled"`
	ClientToken      string           `position:"Body" name:"ClientToken"`
	LoadBalancerName string           `position:"Body" name:"LoadBalancerName"`
	DryRun           requests.Boolean `position:"Body" name:"DryRun"`
	LoadBalancerId   string           `position:"Body" name:"LoadBalancerId"`
}

UpdateLoadBalancerAttributeRequest is the request struct for api UpdateLoadBalancerAttribute

func CreateUpdateLoadBalancerAttributeRequest 

func CreateUpdateLoadBalancerAttributeRequest() (request *UpdateLoadBalancerAttributeRequest)

CreateUpdateLoadBalancerAttributeRequest creates a request to invoke UpdateLoadBalancerAttribute API

type UpdateLoadBalancerAttributeResponse 

type UpdateLoadBalancerAttributeResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateLoadBalancerAttributeResponse is the response struct for api UpdateLoadBalancerAttribute

func CreateUpdateLoadBalancerAttributeResponse 

func CreateUpdateLoadBalancerAttributeResponse() (response *UpdateLoadBalancerAttributeResponse)

CreateUpdateLoadBalancerAttributeResponse creates a response to parse from UpdateLoadBalancerAttribute response

type UpdateLoadBalancerZonesRequest 

type UpdateLoadBalancerZonesRequest struct {
	*requests.RpcRequest
	ClientToken    string                                 `position:"Body" name:"ClientToken"`
	DryRun         requests.Boolean                       `position:"Body" name:"DryRun"`
	ZoneMappings   *[]UpdateLoadBalancerZonesZoneMappings `position:"Body" name:"ZoneMappings"  type:"Repeated"`
	LoadBalancerId string                                 `position:"Body" name:"LoadBalancerId"`
}

UpdateLoadBalancerZonesRequest is the request struct for api UpdateLoadBalancerZones

func CreateUpdateLoadBalancerZonesRequest 

func CreateUpdateLoadBalancerZonesRequest() (request *UpdateLoadBalancerZonesRequest)

CreateUpdateLoadBalancerZonesRequest creates a request to invoke UpdateLoadBalancerZones API

type UpdateLoadBalancerZonesResponse 

type UpdateLoadBalancerZonesResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateLoadBalancerZonesResponse is the response struct for api UpdateLoadBalancerZones

func CreateUpdateLoadBalancerZonesResponse 

func CreateUpdateLoadBalancerZonesResponse() (response *UpdateLoadBalancerZonesResponse)

CreateUpdateLoadBalancerZonesResponse creates a response to parse from UpdateLoadBalancerZones response

type UpdateLoadBalancerZonesZoneMappings 

type UpdateLoadBalancerZonesZoneMappings struct {
	VSwitchId string `name:"VSwitchId"`
	ZoneId    string `name:"ZoneId"`
}

UpdateLoadBalancerZonesZoneMappings is a repeated param struct in UpdateLoadBalancerZonesRequest

type UpdateServerGroupAttributeConnectionDrainConfig 

type UpdateServerGroupAttributeConnectionDrainConfig struct {
	ConnectionDrainEnabled string `name:"ConnectionDrainEnabled"`
	ConnectionDrainTimeout string `name:"ConnectionDrainTimeout"`
}

UpdateServerGroupAttributeConnectionDrainConfig is a repeated param struct in UpdateServerGroupAttributeRequest

type UpdateServerGroupAttributeHealthCheckConfig 

type UpdateServerGroupAttributeHealthCheckConfig struct {
	HealthCheckConnectPort    string    `name:"HealthCheckConnectPort"`
	HealthCheckConnectTimeout string    `name:"HealthCheckConnectTimeout"`
	HealthCheckDomain         string    `name:"HealthCheckDomain"`
	HealthCheckEnabled        string    `name:"HealthCheckEnabled"`
	HealthCheckHttpCode       *[]string `name:"HealthCheckHttpCode" type:"Repeated"`
	HealthCheckInterval       string    `name:"HealthCheckInterval"`
	HealthCheckPath           string    `name:"HealthCheckPath"`
	HealthCheckProtocol       string    `name:"HealthCheckProtocol"`
	HealthyThreshold          string    `name:"HealthyThreshold"`
	UnhealthyThreshold        string    `name:"UnhealthyThreshold"`
}

UpdateServerGroupAttributeHealthCheckConfig is a repeated param struct in UpdateServerGroupAttributeRequest

type UpdateServerGroupAttributeRequest 

type UpdateServerGroupAttributeRequest struct {
	*requests.RpcRequest
	ServerGroupName       string                                          `position:"Body" name:"ServerGroupName"`
	ClientToken           string                                          `position:"Body" name:"ClientToken"`
	HealthCheckConfig     UpdateServerGroupAttributeHealthCheckConfig     `position:"Body" name:"HealthCheckConfig"  type:"Struct"`
	ServerGroupId         string                                          `position:"Body" name:"ServerGroupId"`
	Scheduler             string                                          `position:"Body" name:"Scheduler"`
	DryRun                requests.Boolean                                `position:"Body" name:"DryRun"`
	ConnectionDrainConfig UpdateServerGroupAttributeConnectionDrainConfig `position:"Body" name:"ConnectionDrainConfig"  type:"Struct"`
}

UpdateServerGroupAttributeRequest is the request struct for api UpdateServerGroupAttribute

func CreateUpdateServerGroupAttributeRequest 

func CreateUpdateServerGroupAttributeRequest() (request *UpdateServerGroupAttributeRequest)

CreateUpdateServerGroupAttributeRequest creates a request to invoke UpdateServerGroupAttribute API

type UpdateServerGroupAttributeResponse 

type UpdateServerGroupAttributeResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateServerGroupAttributeResponse is the response struct for api UpdateServerGroupAttribute

func CreateUpdateServerGroupAttributeResponse 

func CreateUpdateServerGroupAttributeResponse() (response *UpdateServerGroupAttributeResponse)

CreateUpdateServerGroupAttributeResponse creates a response to parse from UpdateServerGroupAttribute response

type ZoneEniModel 

type ZoneEniModel struct {
	ZoneId                string      `json:"ZoneId" xml:"ZoneId"`
	VSwitchId             string      `json:"VSwitchId" xml:"VSwitchId"`
	LoadBalancerAddresses []EniModels `json:"LoadBalancerAddresses" xml:"LoadBalancerAddresses"`
}

ZoneEniModel is a nested struct in gwlb response

type ZoneMappingsInGetLoadBalancerAttribute 

type ZoneMappingsInGetLoadBalancerAttribute struct {
	ZoneEniModel []ZoneEniModel `json:"ZoneEniModel" xml:"ZoneEniModel"`
}

ZoneMappingsInGetLoadBalancerAttribute is a nested struct in gwlb response

type ZoneMappingsInListLoadBalancers 

type ZoneMappingsInListLoadBalancers struct {
	ZoneEniModel []ZoneEniModel `json:"ZoneEniModel" xml:"ZoneEniModel"`
}

ZoneMappingsInListLoadBalancers is a nested struct in gwlb response

type Zones 

type Zones struct {
	Data []Data `json:"Data" xml:"Data"`
}

Zones is a nested struct in gwlb response

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.