kubernetes
/
autoscaler
mirror of https://github.com/kubernetes/autoscaler.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3667 from RainbowMango/pr_fix_create_policy_issue 

[CA] update sdk version to fix scaling policy cannot create issue
This commit is contained in:
Kubernetes Prow Robot 2020-11-04 06:08:03 -08:00 committed by GitHub
parent ef0497e31f 46eecdf6fe
commit a0685e1184
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 1338 additions and 1943 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/converter/converters.go
View File

@ -1,7 +1,10 @@
package converter
import "reflect"
type Converter interface {
CovertStringToInterface(value string) (interface{}, error)
CovertStringToPrimitiveTypeAndSetField(field reflect.Value, value string, isPtr bool) error
}
func StringConverterFactory(vType string) Converter {

85
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/converter/types.go
View File

@ -1,6 +1,9 @@
package converter
import "strconv"
import (
"reflect"
"strconv"
)
type Int32Converter struct{}
@ -12,6 +15,20 @@ func (i Int32Converter) CovertStringToInterface(value string) (interface{}, erro
return int32(0), err
}
func (i Int32Converter) CovertStringToPrimitiveTypeAndSetField(field reflect.Value, value string, isPtr bool) error {
v, err := i.CovertStringToInterface(value)
if err != nil {
return err
}
val := v.(int32)
if isPtr {
field.Set(reflect.ValueOf(&val))
} else {
field.Set(reflect.ValueOf(val))
}
return nil
}
type Int64Converter struct{}
func (i Int64Converter) CovertStringToInterface(value string) (interface{}, error) {
@ -22,6 +39,20 @@ func (i Int64Converter) CovertStringToInterface(value string) (interface{}, erro
return int64(0), err
}
func (i Int64Converter) CovertStringToPrimitiveTypeAndSetField(field reflect.Value, value string, isPtr bool) error {
v, err := i.CovertStringToInterface(value)
if err != nil {
return err
}
val := v.(int64)
if isPtr {
field.Set(reflect.ValueOf(&val))
} else {
field.Set(reflect.ValueOf(val))
}
return nil
}
type Float32Converter struct{}
func (i Float32Converter) CovertStringToInterface(value string) (interface{}, error) {
@ -32,6 +63,20 @@ func (i Float32Converter) CovertStringToInterface(value string) (interface{}, er
return float32(0), err
}
func (i Float32Converter) CovertStringToPrimitiveTypeAndSetField(field reflect.Value, value string, isPtr bool) error {
v, err := i.CovertStringToInterface(value)
if err != nil {
return err
}
val := v.(float32)
if isPtr {
field.Set(reflect.ValueOf(&val))
} else {
field.Set(reflect.ValueOf(val))
}
return nil
}
type Float64Converter struct{}
func (i Float64Converter) CovertStringToInterface(value string) (interface{}, error) {
@ -42,6 +87,20 @@ func (i Float64Converter) CovertStringToInterface(value string) (interface{}, er
return float64(0), err
}
func (i Float64Converter) CovertStringToPrimitiveTypeAndSetField(field reflect.Value, value string, isPtr bool) error {
v, err := i.CovertStringToInterface(value)
if err != nil {
return err
}
val := v.(float64)
if isPtr {
field.Set(reflect.ValueOf(&val))
} else {
field.Set(reflect.ValueOf(val))
}
return nil
}
type BooleanConverter struct{}
func (i BooleanConverter) CovertStringToInterface(value string) (interface{}, error) {
@ -52,8 +111,32 @@ func (i BooleanConverter) CovertStringToInterface(value string) (interface{}, er
return false, err
}
func (i BooleanConverter) CovertStringToPrimitiveTypeAndSetField(field reflect.Value, value string, isPtr bool) error {
v, err := i.CovertStringToInterface(value)
if err != nil {
return err
}
val := v.(bool)
if isPtr {
field.Set(reflect.ValueOf(&val))
} else {
field.Set(reflect.ValueOf(val))
}
return nil
}
type StringConverter struct{}
func (i StringConverter) CovertStringToInterface(value string) (interface{}, error) {
return value, nil
}
func (i StringConverter) CovertStringToPrimitiveTypeAndSetField(field reflect.Value, value string, isPtr bool) error {
val := value
if isPtr {
field.Set(reflect.ValueOf(&val))
} else {
field.Set(reflect.ValueOf(val))
}
return nil
}

12
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/def/field.go
View File

@ -31,6 +31,8 @@ const (
type FieldDef struct {
LocationType LocationType
Name string
JsonTag string
KindName string
}
func NewFieldDef() *FieldDef {
@ -46,3 +48,13 @@ func (field *FieldDef) WithName(name string) *FieldDef {
field.Name = name
return field
}
func (field *FieldDef) WithJsonTag(tag string) *FieldDef {
field.JsonTag = tag
return field
}
func (field *FieldDef) WithKindName(kindName string) *FieldDef {
field.KindName = kindName
return field
}

23
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/def/http_request_def.go
View File

@ -20,11 +20,12 @@
package def
type HttpRequestDef struct {
BodyJson interface{}
RequestFields []*FieldDef
Path string
Method string
ContentType string
Method string
Path string
ContentType string
RequestFields []*FieldDef
ResponseFields []*FieldDef
Response interface{}
}
type HttpRequestDefBuilder struct {
@ -33,7 +34,8 @@ type HttpRequestDefBuilder struct {
func NewHttpRequestDefBuilder() *HttpRequestDefBuilder {
httpRequestDef := &HttpRequestDef{
RequestFields: []*FieldDef{},
RequestFields: []*FieldDef{},
ResponseFields: []*FieldDef{},
}
HttpRequestDefBuilder := &HttpRequestDefBuilder{
httpRequestDef: httpRequestDef,
@ -56,8 +58,8 @@ func (builder *HttpRequestDefBuilder) WithContentType(contentType string) *HttpR
return builder
}
func (builder *HttpRequestDefBuilder) WithBodyJson(bodyJson interface{}) *HttpRequestDefBuilder {
builder.httpRequestDef.BodyJson = bodyJson
func (builder *HttpRequestDefBuilder) WithResponse(response interface{}) *HttpRequestDefBuilder {
builder.httpRequestDef.Response = response
return builder
}
@ -66,6 +68,11 @@ func (builder *HttpRequestDefBuilder) WithRequestField(field *FieldDef) *HttpReq
return builder
}
func (builder *HttpRequestDefBuilder) WithResponseField(field *FieldDef) *HttpRequestDefBuilder {
builder.httpRequestDef.ResponseFields = append(builder.httpRequestDef.ResponseFields, field)
return builder
}
func (builder *HttpRequestDefBuilder) Build() *HttpRequestDef {
return builder.httpRequestDef
}

45
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/def/http_response_def.go
View File

@ -1,45 +0,0 @@
// Copyright 2020 Huawei Technologies Co.,Ltd.
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package def
type HttpResponseDef struct {
BodyJson interface{}
}
type HttpResponseDefBuilder struct {
httpResponseDef *HttpResponseDef
}
func NewHttpResponseDefBuilder() *HttpResponseDefBuilder {
HttpResponseDef := &HttpResponseDef{}
HttpResponseDefBuilder := &HttpResponseDefBuilder{
httpResponseDef: HttpResponseDef,
}
return HttpResponseDefBuilder
}
func (builder *HttpResponseDefBuilder) WithBodyJson(bodyJson interface{}) *HttpResponseDefBuilder {
builder.httpResponseDef.BodyJson = bodyJson
return builder
}
func (builder *HttpResponseDefBuilder) Build() *HttpResponseDef {
return builder.httpResponseDef
}

193
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/hc_http_client.go
View File

@ -21,15 +21,18 @@ package core
import (
"bytes"
"encoding/json"
jsoniter "github.com/json-iterator/go"
"io/ioutil"
"errors"
"fmt"
"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/auth"
"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/converter"
"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/def"
"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/impl"
"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/request"
"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/response"
"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/sdkerr"
jsoniter "github.com/json-iterator/go"
"io/ioutil"
"reflect"
"strings"
)
@ -53,7 +56,7 @@ func (hc *HcHttpClient) WithCredential(credential auth.ICredential) *HcHttpClien
return hc
}
func (hc *HcHttpClient) Sync(req interface{}, reqDef *def.HttpRequestDef, responseDef *def.HttpResponseDef) (*response.DefaultHttpResponse, error) {
func (hc *HcHttpClient) Sync(req interface{}, reqDef *def.HttpRequestDef) (interface{}, error) {
httpRequest, err := hc.buildRequest(req, reqDef)
if err != nil {
return nil, err
@ -64,15 +67,14 @@ func (hc *HcHttpClient) Sync(req interface{}, reqDef *def.HttpRequestDef, respon
return nil, err
}
return hc.extractResponse(resp, responseDef)
return hc.extractResponse(resp, reqDef)
}
func (hc *HcHttpClient) buildRequest(req interface{}, reqDef *def.HttpRequestDef) (*request.DefaultHttpRequest, error) {
builder := request.NewHttpRequestBuilder().
WithEndpoint(hc.endpoint).
WithMethod(reqDef.Method).
WithPath(reqDef.Path).
WithBody(reqDef.BodyJson)
WithPath(reqDef.Path)
if reqDef.ContentType != "" {
builder.AddHeaderParam("Content-Type", reqDef.ContentType)
@ -92,74 +94,135 @@ func (hc *HcHttpClient) buildRequest(req interface{}, reqDef *def.HttpRequestDef
}
func (hc *HcHttpClient) fillParamsFromReq(req interface{}, reqDef *def.HttpRequestDef, builder *request.HttpRequestBuilder) (*request.HttpRequestBuilder, error) {
toBytes, err := hc.convertToBytes(req)
if err != nil {
return nil, err
}
attrMaps := hc.GetFieldJsonTags(req)
for _, fieldDef := range reqDef.RequestFields {
value := jsoniter.Get(toBytes.Bytes(), fieldDef.Name).ToString()
if value == "" {
value, err := hc.GetFieldValueByName(fieldDef.Name, attrMaps, req)
if err != nil {
return nil, err
}
if !value.IsValid() {
continue
}
switch fieldDef.LocationType {
case def.Header:
builder.AddHeaderParam(fieldDef.Name, value)
builder.AddHeaderParam(fieldDef.JsonTag, fmt.Sprintf("%v", value))
case def.Path:
builder.AddPathParam(fieldDef.Name, value)
builder.AddPathParam(fieldDef.JsonTag, fmt.Sprintf("%v", value))
case def.Query:
builder.AddQueryParam(fieldDef.Name, value)
builder.AddQueryParam(fieldDef.JsonTag, value)
case def.Body:
builder.WithBody(value.Interface())
}
}
return builder, err
return builder, nil
}
func (hc *HcHttpClient) convertToBytes(req interface{}) (*bytes.Buffer, error) {
buf := &bytes.Buffer{}
err := json.NewEncoder(buf).Encode(req)
func (hc *HcHttpClient) GetFieldJsonTags(structName interface{}) map[string]string {
attrMaps := make(map[string]string)
t := reflect.TypeOf(structName)
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
fieldNum := t.NumField()
for i := 0; i < fieldNum; i++ {
jsonTag := t.Field(i).Tag.Get("json")
if jsonTag != "" {
attrMaps[t.Field(i).Name] = jsonTag
}
}
return attrMaps
}
func (hc *HcHttpClient) GetFieldValueByName(name string, jsonTag map[string]string, structName interface{}) (reflect.Value, error) {
v := reflect.ValueOf(structName)
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
value := v.FieldByName(name)
if value.Kind() == reflect.Ptr {
if value.IsNil() {
if strings.Contains(jsonTag[name], "omitempty") {
return reflect.ValueOf(nil), nil
}
return reflect.ValueOf(nil), errors.New("request field " + name + " read null value")
}
return value.Elem(), nil
}
if value.Kind() == reflect.Struct {
v, err := jsoniter.Marshal(value.Interface())
if strings.HasPrefix(string(v), "\"") {
return reflect.ValueOf(strings.Trim(string(v), "\"")), err
} else {
return reflect.ValueOf(string(v)), err
}
}
return value, nil
}
func (hc *HcHttpClient) extractResponse(resp *response.DefaultHttpResponse, reqDef *def.HttpRequestDef) (interface{}, error) {
if resp.GetStatusCode() >= 400 {
return nil, sdkerr.NewServiceResponseError(resp.Response)
}
err := hc.deserializeResponse(resp, reqDef)
if err != nil {
return nil, err
}
return buf, nil
return reqDef.Response, nil
}
func (hc *HcHttpClient) extractResponse(resp *response.DefaultHttpResponse, responseDef *def.HttpResponseDef) (*response.DefaultHttpResponse, error) {
if resp.GetStatusCode() >= 400 {
return resp, sdkerr.NewServiceResponseError(resp.Response)
}
func (hc *HcHttpClient) deserializeResponse(resp *response.DefaultHttpResponse, reqDef *def.HttpRequestDef) error {
data, err := ioutil.ReadAll(resp.Response.Body)
if err != nil {
if closeErr := resp.Response.Body.Close(); closeErr != nil {
return nil, err
return err
}
return nil, err
return err
}
if err := resp.Response.Body.Close(); err != nil {
return nil, err
return err
} else {
resp.Response.Body = ioutil.NopCloser(bytes.NewBuffer(data))
}
if len(data) == 0 {
return resp, nil
}
err = jsoniter.Unmarshal(data, responseDef.BodyJson)
if err != nil {
if strings.HasPrefix(string(data), "{") {
return nil, sdkerr.ServiceResponseError{
StatusCode: resp.GetStatusCode(),
RequestId: resp.GetHeader("X-Request-Id"),
ErrorMessage: err.Error(),
hasBody := false
for _, item := range reqDef.ResponseFields {
if item.LocationType == def.Header {
err := hc.deserializeResponseHeaders(resp, reqDef, item)
if err != nil {
return sdkerr.ServiceResponseError{
StatusCode: resp.GetStatusCode(),
RequestId: resp.GetHeader("X-Request-Id"),
ErrorMessage: err.Error(),
}
}
}
dataOfListOrString := "{ \"body\" : " + string(data) + "}"
err = jsoniter.Unmarshal([]byte(dataOfListOrString), responseDef.BodyJson)
if item.LocationType == def.Body {
hasBody = true
dataOfListOrString := "{ \"body\" : " + string(data) + "}"
err = jsoniter.Unmarshal([]byte(dataOfListOrString), &reqDef.Response)
if err != nil {
return sdkerr.ServiceResponseError{
StatusCode: resp.GetStatusCode(),
RequestId: resp.GetHeader("X-Request-Id"),
ErrorMessage: err.Error(),
}
}
}
}
if len(data) != 0 && !hasBody {
err = jsoniter.Unmarshal(data, &reqDef.Response)
if err != nil {
return nil, sdkerr.ServiceResponseError{
return sdkerr.ServiceResponseError{
StatusCode: resp.GetStatusCode(),
RequestId: resp.GetHeader("X-Request-Id"),
ErrorMessage: err.Error(),
@ -167,6 +230,44 @@ func (hc *HcHttpClient) extractResponse(resp *response.DefaultHttpResponse, resp
}
}
resp.BodyJson = responseDef.BodyJson
return resp, nil
return nil
}
func (hc *HcHttpClient) deserializeResponseHeaders(resp *response.DefaultHttpResponse, reqDef *def.HttpRequestDef, item *def.FieldDef) error {
isPtr, fieldKind := GetFieldInfo(reqDef, item)
v := reflect.ValueOf(reqDef.Response)
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
fieldValue := v.FieldByName(item.Name)
headerValue := resp.GetHeader(item.JsonTag)
sdkConverter := converter.StringConverterFactory(fieldKind)
if sdkConverter == nil {
return errors.New("failed to convert " + item.JsonTag)
}
err := sdkConverter.CovertStringToPrimitiveTypeAndSetField(fieldValue, headerValue, isPtr)
if err != nil {
return err
}
return nil
}
func GetFieldInfo(reqDef *def.HttpRequestDef, item *def.FieldDef) (bool, string) {
var fieldKind string
var isPtr = false
t := reflect.TypeOf(reqDef.Response)
if t.Kind() == reflect.Ptr {
isPtr = true
t = t.Elem()
}
field, _ := t.FieldByName(item.Name)
if field.Type.Kind() == reflect.Ptr {
fieldKind = field.Type.Elem().Kind().String()
} else {
fieldKind = field.Type.Kind().String()
}
return isPtr, fieldKind
}

24
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/request/default_http_request.go
View File

@ -24,6 +24,7 @@ import (
"encoding/json"
"fmt"
"net/http"
"reflect"
"strings"
)
@ -31,7 +32,7 @@ type DefaultHttpRequest struct {
endpoint string
path string
method string
queryParams map[string]string
queryParams map[string]interface{}
pathParams map[string]string
autoFilledPathParams map[string]string
headerParams map[string]string
@ -65,7 +66,7 @@ func (httpRequest *DefaultHttpRequest) GetMethod() string {
return httpRequest.method
}
func (httpRequest *DefaultHttpRequest) GetQueryParams() map[string]string {
func (httpRequest *DefaultHttpRequest) GetQueryParams() map[string]interface{} {
return httpRequest.queryParams
}
@ -134,18 +135,13 @@ func (httpRequest *DefaultHttpRequest) fillQueryParams(req *http.Request) {
}
q := req.URL.Query()
for key, value := range httpRequest.GetQueryParams() {
if strings.HasPrefix(value, "[") {
var valueList []interface{}
err := json.Unmarshal([]byte(value), &valueList)
if err == nil {
for item := range valueList {
q.Add(key, fmt.Sprintf("%v", valueList[item]))
}
} else {
q.Add(key, value)
if reflect.TypeOf(value).Kind() == reflect.Struct && value.(reflect.Value).Kind() == reflect.Slice {
s := value.(reflect.Value)
for i := 0; i < s.Len(); i++ {
q.Add(key, fmt.Sprintf("%v", s.Index(i)))
}
} else {
q.Add(key, value)
q.Add(key, fmt.Sprintf("%v", value))
}
}
req.URL.RawQuery = q.Encode()
@ -163,7 +159,7 @@ type HttpRequestBuilder struct {
func NewHttpRequestBuilder() *HttpRequestBuilder {
httpRequest := &DefaultHttpRequest{
queryParams: make(map[string]string),
queryParams: make(map[string]interface{}),
headerParams: make(map[string]string),
pathParams: make(map[string]string),
autoFilledPathParams: make(map[string]string),
@ -189,7 +185,7 @@ func (builder *HttpRequestBuilder) WithMethod(method string) *HttpRequestBuilder
return builder
}
func (builder *HttpRequestBuilder) AddQueryParam(key string, value string) *HttpRequestBuilder {
func (builder *HttpRequestBuilder) AddQueryParam(key string, value interface{}) *HttpRequestBuilder {
builder.httpRequest.queryParams[key] = value
return builder
}

4
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/request/http_request.go
View File

@ -24,11 +24,11 @@ import "bytes"
type HttpRequest interface {
Builder() *HttpRequestBuilder
GetEndpoint() string
GetPath() string
GetMethod() string
GetQueryParams() map[string]string
GetPath() string
GetHeaderParams() map[string]string
GetPathPrams() map[string]string
GetQueryParams() map[string]interface{}
GetBody() interface{}
GetBodyToBytes() (*bytes.Buffer, error)
}

5
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/response/default_http_response.go
View File

@ -27,7 +27,6 @@ import (
type DefaultHttpResponse struct {
Response *http.Response
BodyJson interface{}
}
func NewDefaultHttpResponse(response *http.Response) *DefaultHttpResponse {
@ -60,10 +59,6 @@ func (r *DefaultHttpResponse) GetBody() string {
return string(body)
}
func (r *DefaultHttpResponse) GetBodyJson() interface{} {
return r.BodyJson
}
func (r *DefaultHttpResponse) GetHeader(key string) string {
header := r.Response.Header
return header.Get(key)

12
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/core/sdktime/sdk_time.go
View File

@ -1,6 +1,7 @@
package sdktime
import (
"fmt"
"strings"
"time"
)
@ -23,6 +24,13 @@ func (t *SdkTime) UnmarshalJSON(data []byte) error {
return nil
}
func (t SdkTime) String() string {
return time.Time(t).Format(`2006-01-02T15:04:05Z`)
func (t SdkTime) MarshalJSON() ([]byte, error) {
rs := []byte(fmt.Sprintf(`"%s"`, t.String()))
return rs, nil
}
func (t SdkTime) String() string {
// return time.Time(t).Format(`2006-01-02T15:04:05Z`)
// temp solution for: https://github.com/huaweicloud/huaweicloud-sdk-go-v3/issues/8
return time.Time(t).Format(`2006-01-02T15:04Z`)
}

273
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/services/as/v1/as_client.go
View File

@ -20,468 +20,429 @@ func AsClientBuilder() *http_client.HcHttpClientBuilder {
//批量删除指定弹性伸缩配置。被伸缩组使用的伸缩配置不能被删除。单次最多删除伸缩配置个数为50。
func (c *AsClient) BatchDeleteScalingConfigs(request *model.BatchDeleteScalingConfigsRequest) (*model.BatchDeleteScalingConfigsResponse, error) {
requestDef := GenReqDefForBatchDeleteScalingConfigs(request)
resp, responseDef := GenRespForBatchDeleteScalingConfigs()
requestDef := GenReqDefForBatchDeleteScalingConfigs()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.BatchDeleteScalingConfigsResponse), nil
}
}
//通过生命周期操作令牌或者通过实例ID和生命周期挂钩名称对伸缩实例指定的挂钩进行回调操作。如果在超时时间结束前已完成自定义操作，选择终止或继续完成生命周期操作。如果需要更多时间完成自定义操作，选择延长超时时间，实例保持等待状态的时间将增加1小时。只有实例的生命周期挂钩状态为 HANGING 时才可以进行回调操作。
func (c *AsClient) CompleteLifecycleAction(request *model.CompleteLifecycleActionRequest) (*model.CompleteLifecycleActionResponse, error) {
requestDef := GenReqDefForCompleteLifecycleAction(request)
resp, responseDef := GenRespForCompleteLifecycleAction()
requestDef := GenReqDefForCompleteLifecycleAction()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CompleteLifecycleActionResponse), nil
}
}
//创建生命周期挂钩，可为伸缩组添加一个或多个生命周期挂钩，最多添加5个。添加生命周期挂钩后，当伸缩组进行伸缩活动时，实例将被生命周期挂钩挂起并置于等待状态（正在加入伸缩组或正在移出伸缩组），实例将保持此状态直至超时时间结束或者用户手动回调。用户能够在实例保持等待状态的时间段内执行自定义操作，例如，用户可以在新启动的实例上安装或配置软件，也可以在实例终止前从实例中下载日志文件。
func (c *AsClient) CreateLifyCycleHook(request *model.CreateLifyCycleHookRequest) (*model.CreateLifyCycleHookResponse, error) {
requestDef := GenReqDefForCreateLifyCycleHook(request)
resp, responseDef := GenRespForCreateLifyCycleHook()
requestDef := GenReqDefForCreateLifyCycleHook()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreateLifyCycleHookResponse), nil
}
}
//创建弹性伸缩配置。伸缩配置是伸缩组内实例（弹性云服务器云主机）的模板，定义了伸缩组内待添加的实例的规格数据。伸缩配置与伸缩组是解耦的，同一伸缩配置可以被多个伸缩组使用。默认最多可以创建100个伸缩配置。
func (c *AsClient) CreateScalingConfig(request *model.CreateScalingConfigRequest) (*model.CreateScalingConfigResponse, error) {
requestDef := GenReqDefForCreateScalingConfig(request)
resp, responseDef := GenRespForCreateScalingConfig()
requestDef := GenReqDefForCreateScalingConfig()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreateScalingConfigResponse), nil
}
}
//伸缩组是具有相同应用场景的实例的集合，是启停伸缩策略和进行伸缩活动的基本单位。伸缩组内定义了最大实例数、期望实例数、最小实例数、虚拟私有云、子网、负载均衡等信息。默认最多可以创建10个伸缩组。如果伸缩组配置了负载均衡，在添加或移除实例时，会自动为实例绑定或解绑负载均衡监听器。如果伸缩组使用负载均衡健康检查方式，伸缩组中的实例需要启用负载均衡器的监听端口才能通过健康检查。端口启用可在安全组中进行配置，可参考添加安全组规则进行操作。
func (c *AsClient) CreateScalingGroup(request *model.CreateScalingGroupRequest) (*model.CreateScalingGroupResponse, error) {
requestDef := GenReqDefForCreateScalingGroup(request)
resp, responseDef := GenRespForCreateScalingGroup()
requestDef := GenReqDefForCreateScalingGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreateScalingGroupResponse), nil
}
}
//给弹性伸缩组配置通知功能。每调用一次该接口，伸缩组即配置一个通知主题及其通知场景，每个伸缩组最多可以增加5个主题。通知主题由用户事先在SMN创建并进行订阅，当通知主题对应的通知场景出现时，伸缩组会向用户的订阅终端发送通知。
func (c *AsClient) CreateScalingNotification(request *model.CreateScalingNotificationRequest) (*model.CreateScalingNotificationResponse, error) {
requestDef := GenReqDefForCreateScalingNotification(request)
resp, responseDef := GenRespForCreateScalingNotification()
requestDef := GenReqDefForCreateScalingNotification()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreateScalingNotificationResponse), nil
}
}
//创建弹性伸缩策略。伸缩策略定义了伸缩组内实例的扩张和收缩操作。如果执行伸缩策略造成伸缩组期望实例数与伸缩组内实例数不符，弹性伸缩会自动调整实例资源，以匹配期望实例数。当前伸缩策略支持告警触发策略，周期触发策略，定时触发策略。在策略执行具体动作中，可设置实例变化的个数，或根据当前实例的百分比数进行伸缩。
func (c *AsClient) CreateScalingPolicy(request *model.CreateScalingPolicyRequest) (*model.CreateScalingPolicyResponse, error) {
requestDef := GenReqDefForCreateScalingPolicy(request)
resp, responseDef := GenRespForCreateScalingPolicy()
requestDef := GenReqDefForCreateScalingPolicy()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreateScalingPolicyResponse), nil
}
}
//创建或删除指定资源的标签。每个伸缩组最多添加10个标签。
func (c *AsClient) CreateScalingTags(request *model.CreateScalingTagsRequest) (*model.CreateScalingTagsResponse, error) {
requestDef := GenReqDefForCreateScalingTags(request)
resp, responseDef := GenRespForCreateScalingTags()
requestDef := GenReqDefForCreateScalingTags()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreateScalingTagsResponse), nil
}
}
//删除一个指定生命周期挂钩。伸缩组进行伸缩活动时，不允许删除该伸缩组内的生命周期挂钩。
func (c *AsClient) DeleteLifecycleHook(request *model.DeleteLifecycleHookRequest) (*model.DeleteLifecycleHookResponse, error) {
requestDef := GenReqDefForDeleteLifecycleHook(request)
resp, responseDef := GenRespForDeleteLifecycleHook()
requestDef := GenReqDefForDeleteLifecycleHook()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteLifecycleHookResponse), nil
}
}
//删除一个指定弹性伸缩配置。
func (c *AsClient) DeleteScalingConfig(request *model.DeleteScalingConfigRequest) (*model.DeleteScalingConfigResponse, error) {
requestDef := GenReqDefForDeleteScalingConfig(request)
resp, responseDef := GenRespForDeleteScalingConfig()
requestDef := GenReqDefForDeleteScalingConfig()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteScalingConfigResponse), nil
}
}
//删除一个指定弹性伸缩组。force_delete属性表示如果伸缩组存在ECS实例或正在进行伸缩活动，是否强制删除伸缩组并移出和释放ECS实例。默认值为no，表示不强制删除伸缩组。如果force_delete的值为no，必须满足以下两个条件，才能删除伸缩组：条件一：伸缩组没有正在进行的伸缩活动。条件二：伸缩组当前的ECS实例数量（current_instance_number）为0。如果force_delete的值为yes，伸缩组会被置于DELETING状态，拒绝接收新的伸缩活动请求，然后等待已有的伸缩活动完成，最后将伸缩组内所有ECS实例移出伸缩组（用户手动添加的ECS实例会被移出伸缩组，弹性伸缩自动创建的ECS实例会被自动删除）并删除伸缩组。
func (c *AsClient) DeleteScalingGroup(request *model.DeleteScalingGroupRequest) (*model.DeleteScalingGroupResponse, error) {
requestDef := GenReqDefForDeleteScalingGroup(request)
resp, responseDef := GenRespForDeleteScalingGroup()
requestDef := GenReqDefForDeleteScalingGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteScalingGroupResponse), nil
}
}
//从弹性伸缩组中移出一个指定实例。实例处于INSERVICE且移出后实例数不能小于伸缩组的最小实例数时才可以移出。当伸缩组没有伸缩活动时，才能移出实例。
func (c *AsClient) DeleteScalingInstance(request *model.DeleteScalingInstanceRequest) (*model.DeleteScalingInstanceResponse, error) {
requestDef := GenReqDefForDeleteScalingInstance(request)
resp, responseDef := GenRespForDeleteScalingInstance()
requestDef := GenReqDefForDeleteScalingInstance()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteScalingInstanceResponse), nil
}
}
//删除指定的弹性伸缩组中指定的通知。
func (c *AsClient) DeleteScalingNotification(request *model.DeleteScalingNotificationRequest) (*model.DeleteScalingNotificationResponse, error) {
requestDef := GenReqDefForDeleteScalingNotification(request)
resp, responseDef := GenRespForDeleteScalingNotification()
requestDef := GenReqDefForDeleteScalingNotification()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteScalingNotificationResponse), nil
}
}
//删除一个指定弹性伸缩策略。
func (c *AsClient) DeleteScalingPolicy(request *model.DeleteScalingPolicyRequest) (*model.DeleteScalingPolicyResponse, error) {
requestDef := GenReqDefForDeleteScalingPolicy(request)
resp, responseDef := GenRespForDeleteScalingPolicy()
requestDef := GenReqDefForDeleteScalingPolicy()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteScalingPolicyResponse), nil
}
}
//创建或删除指定资源的标签。每个伸缩组最多添加10个标签。
func (c *AsClient) DeleteScalingTags(request *model.DeleteScalingTagsRequest) (*model.DeleteScalingTagsResponse, error) {
requestDef := GenReqDefForDeleteScalingTags(request)
resp, responseDef := GenRespForDeleteScalingTags()
requestDef := GenReqDefForDeleteScalingTags()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteScalingTagsResponse), nil
}
}
//启用或停止一个指定弹性伸缩组。已停用状态的伸缩组，不会自动触发任何伸缩活动。当伸缩组正在进行伸缩活动，即使停用，正在进行的伸缩活动也不会立即停止。
func (c *AsClient) EnableOrDisableScalingGroup(request *model.EnableOrDisableScalingGroupRequest) (*model.EnableOrDisableScalingGroupResponse, error) {
requestDef := GenReqDefForEnableOrDisableScalingGroup(request)
resp, responseDef := GenRespForEnableOrDisableScalingGroup()
requestDef := GenReqDefForEnableOrDisableScalingGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.EnableOrDisableScalingGroupResponse), nil
}
}
//立即执行或启用或停止一个指定弹性伸缩策略。当伸缩组、伸缩策略状态处于INSERVICE时，伸缩策略才能被正确执行，否则会执行失败。
func (c *AsClient) ExecuteScalingPolicy(request *model.ExecuteScalingPolicyRequest) (*model.ExecuteScalingPolicyResponse, error) {
requestDef := GenReqDefForExecuteScalingPolicy(request)
resp, responseDef := GenRespForExecuteScalingPolicy()
requestDef := GenReqDefForExecuteScalingPolicy()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ExecuteScalingPolicyResponse), nil
}
}
//添加生命周期挂钩后，当伸缩组进行伸缩活动时，实例将被挂钩挂起并置于等待状态，根据输入条件过滤查询弹性伸缩组中伸缩实例的挂起信息。可根据实例ID进行条件过滤查询。若不加过滤条件默认查询指定伸缩组内所有实例挂起信息。
func (c *AsClient) ListHookInstances(request *model.ListHookInstancesRequest) (*model.ListHookInstancesResponse, error) {
requestDef := GenReqDefForListHookInstances(request)
resp, responseDef := GenRespForListHookInstances()
requestDef := GenReqDefForListHookInstances()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListHookInstancesResponse), nil
}
}
//根据伸缩组ID查询生命周期挂钩列表。
func (c *AsClient) ListLifeCycleHooks(request *model.ListLifeCycleHooksRequest) (*model.ListLifeCycleHooksResponse, error) {
requestDef := GenReqDefForListLifeCycleHooks(request)
resp, responseDef := GenRespForListLifeCycleHooks()
requestDef := GenReqDefForListLifeCycleHooks()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListLifeCycleHooksResponse), nil
}
}
//根据项目ID查询指定资源类型的资源实例。资源、资源tag默认按照创建时间倒序。
func (c *AsClient) ListResourceInstances(request *model.ListResourceInstancesRequest) (*model.ListResourceInstancesResponse, error) {
requestDef := GenReqDefForListResourceInstances(request)
resp, responseDef := GenRespForListResourceInstances()
requestDef := GenReqDefForListResourceInstances()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListResourceInstancesResponse), nil
}
}
//根据输入条件过滤查询伸缩活动日志。查询结果分页显示。可根据起始时间，截止时间，起始行号，记录数进行条件过滤查询。若不加过滤条件默认查询最多20条伸缩活动日志信息。
func (c *AsClient) ListScalingActivityLogs(request *model.ListScalingActivityLogsRequest) (*model.ListScalingActivityLogsResponse, error) {
requestDef := GenReqDefForListScalingActivityLogs(request)
resp, responseDef := GenRespForListScalingActivityLogs()
requestDef := GenReqDefForListScalingActivityLogs()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingActivityLogsResponse), nil
}
}
//根据输入条件过滤查询弹性伸缩配置。查询结果分页显示。可以根据伸缩配置名称，镜像ID，起始行号，记录条数进行条件过滤查询。若不加过滤条件默认最多查询租户下20条伸缩配置信息。
func (c *AsClient) ListScalingConfigs(request *model.ListScalingConfigsRequest) (*model.ListScalingConfigsResponse, error) {
requestDef := GenReqDefForListScalingConfigs(request)
resp, responseDef := GenRespForListScalingConfigs()
requestDef := GenReqDefForListScalingConfigs()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingConfigsResponse), nil
}
}
//根据输入条件过滤查询弹性伸缩组列表。查询结果分页显示。可根据伸缩组名称，伸缩配置ID，伸缩组状态，企业项目ID，起始行号，记录条数进行条件过滤查询。若不加过滤条件默认最多查询租户下20条伸缩组信息。
func (c *AsClient) ListScalingGroups(request *model.ListScalingGroupsRequest) (*model.ListScalingGroupsResponse, error) {
requestDef := GenReqDefForListScalingGroups(request)
resp, responseDef := GenRespForListScalingGroups()
requestDef := GenReqDefForListScalingGroups()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingGroupsResponse), nil
}
}
//根据输入条件过滤查询弹性伸缩组中实例信息。查询结果分页显示。可根据实例在伸缩组中的生命周期状态，实例健康状态，实例保护状态，起始行号，记录条数进行条件过滤查询。若不加过滤条件默认查询组内最多20条实例信息
func (c *AsClient) ListScalingInstances(request *model.ListScalingInstancesRequest) (*model.ListScalingInstancesResponse, error) {
requestDef := GenReqDefForListScalingInstances(request)
resp, responseDef := GenRespForListScalingInstances()
requestDef := GenReqDefForListScalingInstances()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingInstancesResponse), nil
}
}
//根据伸缩组ID查询指定弹性伸缩组的通知列表。
func (c *AsClient) ListScalingNotifications(request *model.ListScalingNotificationsRequest) (*model.ListScalingNotificationsResponse, error) {
requestDef := GenReqDefForListScalingNotifications(request)
resp, responseDef := GenRespForListScalingNotifications()
requestDef := GenReqDefForListScalingNotifications()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingNotificationsResponse), nil
}
}
//根据输入条件过滤查询弹性伸缩策略。查询结果分页显示。可根据伸缩策略名称，策略类型，伸缩策略ID，起始行号，记录数进行条件过滤查询。若不加过滤条件默认查询租户下指定伸缩组内最多20条伸缩策略信息。
func (c *AsClient) ListScalingPolicies(request *model.ListScalingPoliciesRequest) (*model.ListScalingPoliciesResponse, error) {
requestDef := GenReqDefForListScalingPolicies(request)
resp, responseDef := GenRespForListScalingPolicies()
requestDef := GenReqDefForListScalingPolicies()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingPoliciesResponse), nil
}
}
//根据输入条件过滤查询策略执行的历史记录。查询结果分页显示。可根据日志ID，伸缩资源类型，伸缩资源ID，策略执行类型，查询额起始，查询截止时间，查询起始行号，查询记录数进行条件过滤查询。若不加过滤条件默认查询最多20条策略执行日志信息。
func (c *AsClient) ListScalingPolicyExecuteLogs(request *model.ListScalingPolicyExecuteLogsRequest) (*model.ListScalingPolicyExecuteLogsResponse, error) {
requestDef := GenReqDefForListScalingPolicyExecuteLogs(request)
resp, responseDef := GenRespForListScalingPolicyExecuteLogs()
requestDef := GenReqDefForListScalingPolicyExecuteLogs()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingPolicyExecuteLogsResponse), nil
}
}
//根据项目ID和资源ID查询指定资源类型的资源标签列表。
func (c *AsClient) ListScalingTagInfosByResourceId(request *model.ListScalingTagInfosByResourceIdRequest) (*model.ListScalingTagInfosByResourceIdResponse, error) {
requestDef := GenReqDefForListScalingTagInfosByResourceId(request)
resp, responseDef := GenRespForListScalingTagInfosByResourceId()
requestDef := GenReqDefForListScalingTagInfosByResourceId()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingTagInfosByResourceIdResponse), nil
}
}
//根据项目ID查询指定资源类型的标签列表。
func (c *AsClient) ListScalingTagInfosByTenantId(request *model.ListScalingTagInfosByTenantIdRequest) (*model.ListScalingTagInfosByTenantIdResponse, error) {
requestDef := GenReqDefForListScalingTagInfosByTenantId(request)
resp, responseDef := GenRespForListScalingTagInfosByTenantId()
requestDef := GenReqDefForListScalingTagInfosByTenantId()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListScalingTagInfosByTenantIdResponse), nil
}
}
//根据伸缩组ID及生命周期挂钩名称查询指定的生命周期挂钩详情。
func (c *AsClient) ShowLifeCycleHook(request *model.ShowLifeCycleHookRequest) (*model.ShowLifeCycleHookResponse, error) {
requestDef := GenReqDefForShowLifeCycleHook(request)
resp, responseDef := GenRespForShowLifeCycleHook()
requestDef := GenReqDefForShowLifeCycleHook()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowLifeCycleHookResponse), nil
}
}
//根据伸缩组ID查询指定弹性伸缩组下的伸缩策略和伸缩实例的配额总数及已使用配额数。
func (c *AsClient) ShowPolicyAndInstanceQuota(request *model.ShowPolicyAndInstanceQuotaRequest) (*model.ShowPolicyAndInstanceQuotaResponse, error) {
requestDef := GenReqDefForShowPolicyAndInstanceQuota(request)
resp, responseDef := GenRespForShowPolicyAndInstanceQuota()
requestDef := GenReqDefForShowPolicyAndInstanceQuota()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowPolicyAndInstanceQuotaResponse), nil
}
}
//查询指定租户下的弹性伸缩组、伸缩配置、伸缩带宽策略、伸缩策略和伸缩实例的配额总数及已使用配额数。
func (c *AsClient) ShowResourceQuota(request *model.ShowResourceQuotaRequest) (*model.ShowResourceQuotaResponse, error) {
requestDef := GenReqDefForShowResourceQuota(request)
resp, responseDef := GenRespForShowResourceQuota()
requestDef := GenReqDefForShowResourceQuota()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowResourceQuotaResponse), nil
}
}
//根据伸缩配置ID查询一个弹性伸缩配置的详细信息。
func (c *AsClient) ShowScalingConfig(request *model.ShowScalingConfigRequest) (*model.ShowScalingConfigResponse, error) {
requestDef := GenReqDefForShowScalingConfig(request)
resp, responseDef := GenRespForShowScalingConfig()
requestDef := GenReqDefForShowScalingConfig()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowScalingConfigResponse), nil
}
}
//查询一个指定弹性伸缩组详情。
func (c *AsClient) ShowScalingGroup(request *model.ShowScalingGroupRequest) (*model.ShowScalingGroupResponse, error) {
requestDef := GenReqDefForShowScalingGroup(request)
resp, responseDef := GenRespForShowScalingGroup()
requestDef := GenReqDefForShowScalingGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowScalingGroupResponse), nil
}
}
//查询指定弹性伸缩策略信息。
func (c *AsClient) ShowScalingPolicy(request *model.ShowScalingPolicyRequest) (*model.ShowScalingPolicyResponse, error) {
requestDef := GenReqDefForShowScalingPolicy(request)
resp, responseDef := GenRespForShowScalingPolicy()
requestDef := GenReqDefForShowScalingPolicy()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowScalingPolicyResponse), nil
}
}
//修改一个指定生命周期挂钩中的信息。
func (c *AsClient) UpdateLifeCycleHook(request *model.UpdateLifeCycleHookRequest) (*model.UpdateLifeCycleHookResponse, error) {
requestDef := GenReqDefForUpdateLifeCycleHook(request)
resp, responseDef := GenRespForUpdateLifeCycleHook()
requestDef := GenReqDefForUpdateLifeCycleHook()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.UpdateLifeCycleHookResponse), nil
}
}
//修改一个指定弹性伸缩组中的信息。更换伸缩组的伸缩配置，伸缩组中已经存在的使用之前伸缩配置创建的云服务器云主机不受影响。伸缩组为没有正在进行的伸缩活动时，可以修改伸缩组的子网、可用区和负载均衡配置。当伸缩组的期望实例数改变时，会触发伸缩活动加入或移出实例。期望实例数必须大于或等于最小实例数，必须小于或等于最大实例数。
func (c *AsClient) UpdateScalingGroup(request *model.UpdateScalingGroupRequest) (*model.UpdateScalingGroupResponse, error) {
requestDef := GenReqDefForUpdateScalingGroup(request)
resp, responseDef := GenRespForUpdateScalingGroup()
requestDef := GenReqDefForUpdateScalingGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.UpdateScalingGroupResponse), nil
}
}
//批量移出伸缩组中的实例或批量添加伸缩组外的实例。批量对伸缩组中的实例设置或取消其实例保护属性。批量将伸缩组中的实例转入或移出备用状态。
func (c *AsClient) UpdateScalingGroupInstance(request *model.UpdateScalingGroupInstanceRequest) (*model.UpdateScalingGroupInstanceResponse, error) {
requestDef := GenReqDefForUpdateScalingGroupInstance(request)
resp, responseDef := GenRespForUpdateScalingGroupInstance()
requestDef := GenReqDefForUpdateScalingGroupInstance()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.UpdateScalingGroupInstanceResponse), nil
}
}
//修改指定弹性伸缩策略。
func (c *AsClient) UpdateScalingPolicy(request *model.UpdateScalingPolicyRequest) (*model.UpdateScalingPolicyResponse, error) {
requestDef := GenReqDefForUpdateScalingPolicy(request)
resp, responseDef := GenRespForUpdateScalingPolicy()
requestDef := GenReqDefForUpdateScalingPolicy()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.UpdateScalingPolicyResponse), nil
}
}

1059
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/services/as/v1/as_meta.go
View File

File diff suppressed because it is too large Load Diff

322
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/services/ecs/v2/ecs_client.go
View File

@ -20,552 +20,506 @@ func EcsClientBuilder() *http_client.HcHttpClientBuilder {
//将云服务器加入云服务器组。添加成功后，如果该云服务器组是反亲和性策略的，则该云服务器与云服务器组中的其他成员尽量分散地创建在不同主机上。如果该云服务器时故障域类型的，则该云服务器会拥有故障域属性。
func (c *EcsClient) AddServerGroupMember(request *model.AddServerGroupMemberRequest) (*model.AddServerGroupMemberResponse, error) {
requestDef := GenReqDefForAddServerGroupMember(request)
resp, responseDef := GenRespForAddServerGroupMember()
requestDef := GenReqDefForAddServerGroupMember()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.AddServerGroupMemberResponse), nil
}
}
//把磁盘挂载到弹性云服务器上。
func (c *EcsClient) AttachServerVolume(request *model.AttachServerVolumeRequest) (*model.AttachServerVolumeResponse, error) {
requestDef := GenReqDefForAttachServerVolume(request)
resp, responseDef := GenRespForAttachServerVolume()
requestDef := GenReqDefForAttachServerVolume()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.AttachServerVolumeResponse), nil
}
}
//给云服务器添加一张或多张网卡。
func (c *EcsClient) BatchAddServerNics(request *model.BatchAddServerNicsRequest) (*model.BatchAddServerNicsResponse, error) {
requestDef := GenReqDefForBatchAddServerNics(request)
resp, responseDef := GenRespForBatchAddServerNics()
requestDef := GenReqDefForBatchAddServerNics()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.BatchAddServerNicsResponse), nil
}
}
//- 为指定云服务器批量添加标签。 - 标签管理服务TMS使用该接口批量管理云服务器的标签。
func (c *EcsClient) BatchCreateServerTags(request *model.BatchCreateServerTagsRequest) (*model.BatchCreateServerTagsResponse, error) {
requestDef := GenReqDefForBatchCreateServerTags(request)
resp, responseDef := GenRespForBatchCreateServerTags()
requestDef := GenReqDefForBatchCreateServerTags()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.BatchCreateServerTagsResponse), nil
}
}
//卸载并删除云服务器中的一张或多张网卡。
func (c *EcsClient) BatchDeleteServerNics(request *model.BatchDeleteServerNicsRequest) (*model.BatchDeleteServerNicsResponse, error) {
requestDef := GenReqDefForBatchDeleteServerNics(request)
resp, responseDef := GenRespForBatchDeleteServerNics()
requestDef := GenReqDefForBatchDeleteServerNics()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.BatchDeleteServerNicsResponse), nil
}
}
//- 为指定云服务器批量删除标签。 - 标签管理服务TMS使用该接口批量管理云服务器的标签。
func (c *EcsClient) BatchDeleteServerTags(request *model.BatchDeleteServerTagsRequest) (*model.BatchDeleteServerTagsResponse, error) {
requestDef := GenReqDefForBatchDeleteServerTags(request)
resp, responseDef := GenRespForBatchDeleteServerTags()
requestDef := GenReqDefForBatchDeleteServerTags()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.BatchDeleteServerTagsResponse), nil
}
}
//根据给定的云服务器ID列表，批量重启云服务器，一次最多可以重启1000台。
func (c *EcsClient) BatchRebootServers(request *model.BatchRebootServersRequest) (*model.BatchRebootServersResponse, error) {
requestDef := GenReqDefForBatchRebootServers(request)
resp, responseDef := GenRespForBatchRebootServers()
requestDef := GenReqDefForBatchRebootServers()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.BatchRebootServersResponse), nil
}
}
//根据给定的云服务器ID列表，批量启动云服务器，一次最多可以启动1000台。
func (c *EcsClient) BatchStartServers(request *model.BatchStartServersRequest) (*model.BatchStartServersResponse, error) {
requestDef := GenReqDefForBatchStartServers(request)
resp, responseDef := GenRespForBatchStartServers()
requestDef := GenReqDefForBatchStartServers()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.BatchStartServersResponse), nil
}
}
//根据给定的云服务器ID列表，批量关闭云服务器，一次最多可以关闭1000台。
func (c *EcsClient) BatchStopServers(request *model.BatchStopServersRequest) (*model.BatchStopServersResponse, error) {
requestDef := GenReqDefForBatchStopServers(request)
resp, responseDef := GenRespForBatchStopServers()
requestDef := GenReqDefForBatchStopServers()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.BatchStopServersResponse), nil
}
}
//切换弹性云服务器操作系统。支持弹性云服务器数据盘不变的情况下，使用新镜像重装系统盘。 调用该接口后，系统将卸载系统盘，然后使用新镜像重新创建系统盘，并挂载至弹性云服务器，实现切换操作系统功能。
func (c *EcsClient) ChangeServerOsWithCloudInit(request *model.ChangeServerOsWithCloudInitRequest) (*model.ChangeServerOsWithCloudInitResponse, error) {
requestDef := GenReqDefForChangeServerOsWithCloudInit(request)
resp, responseDef := GenRespForChangeServerOsWithCloudInit()
requestDef := GenReqDefForChangeServerOsWithCloudInit()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ChangeServerOsWithCloudInitResponse), nil
}
}
//创建一台或多台按需付费方式的云服务器。 弹性云服务器的登录鉴权方式包括两种：密钥对、密码。为安全起见，推荐使用密钥对方式。 - 密钥对 密钥对指使用密钥对作为弹性云服务器的鉴权方式。 接口调用方法：使用key_name字段，指定弹性云服务器登录时使用的密钥文件。 - 密码 密码指使用设置初始密码方式作为弹性云服务器的鉴权方式，此时，您可以通过用户名密码方式登录弹性云服务器，Linux操作系统时为root用户的初始密码，Windows操作系统时为Administrator用户的初始密码。 接口调用方法：使用adminPass字段，指定管理员帐号的初始登录密码。对于镜像已安装Cloud-init的Linux云服务器，如果需要使用密文密码，可以使用user_data字段进行密码注入。 > 对于安装Cloud-init镜像的Linux云服务器云主机，若指定user_data字段，则adminPass字段无效。
func (c *EcsClient) CreatePostPaidServers(request *model.CreatePostPaidServersRequest) (*model.CreatePostPaidServersResponse, error) {
requestDef := GenReqDefForCreatePostPaidServers(request)
resp, responseDef := GenRespForCreatePostPaidServers()
requestDef := GenReqDefForCreatePostPaidServers()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreatePostPaidServersResponse), nil
}
}
//创建弹性云服务器组。 与原生的创建云服务器组接口不同之处在于该接口支持企业项目细粒度权限的校验。
func (c *EcsClient) CreateServerGroup(request *model.CreateServerGroupRequest) (*model.CreateServerGroupResponse, error) {
requestDef := GenReqDefForCreateServerGroup(request)
resp, responseDef := GenRespForCreateServerGroup()
requestDef := GenReqDefForCreateServerGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreateServerGroupResponse), nil
}
}
//创建一台或多台云服务器。 指该接口兼容《弹性云服务器接口参考》创建云服务器v1的功能，同时合入新功能，支持创建包年/包月的弹性云服务器。 弹性云服务器的登录鉴权方式包括两种：密钥对、密码。为安全起见，推荐使用密钥对方式。 - 密钥对 指使用密钥对作为弹性云服务器的鉴权方式。 接口调用方法：使用key_name字段，指定弹性云服务器登录时使用的密钥文件。 - 密码 指使用设置初始密码方式作为弹性云服务器的鉴权方式，此时，您可以通过用户名密码方式登录弹性云服务器，Linux操作系统时为root用户的初始密码，Windows操作系统时为Administrator用户的初始密码。 接口调用方法：使用adminPass字段，指定管理员帐号的初始登录密码。对于镜像已安装Cloud-init的Linux云服务器，如果需要使用密文密码，可以使用user_data字段进行密码注入。 > 对于安装Cloud-init镜像的Linux云服务器云主机，若指定user_data字段，则adminPass字段无效。
func (c *EcsClient) CreateServers(request *model.CreateServersRequest) (*model.CreateServersResponse, error) {
requestDef := GenReqDefForCreateServers(request)
resp, responseDef := GenRespForCreateServers()
requestDef := GenReqDefForCreateServers()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.CreateServersResponse), nil
}
}
//删除云服务器组。 与原生的删除云服务器组接口不同之处在于该接口支持企业项目细粒度权限的校验。
func (c *EcsClient) DeleteServerGroup(request *model.DeleteServerGroupRequest) (*model.DeleteServerGroupResponse, error) {
requestDef := GenReqDefForDeleteServerGroup(request)
resp, responseDef := GenRespForDeleteServerGroup()
requestDef := GenReqDefForDeleteServerGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteServerGroupResponse), nil
}
}
//将弹性云服务器移出云服务器组。移出后，该云服务器与云服务器组中的成员不再遵从反亲和策略。
func (c *EcsClient) DeleteServerGroupMember(request *model.DeleteServerGroupMemberRequest) (*model.DeleteServerGroupMemberResponse, error) {
requestDef := GenReqDefForDeleteServerGroupMember(request)
resp, responseDef := GenRespForDeleteServerGroupMember()
requestDef := GenReqDefForDeleteServerGroupMember()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteServerGroupMemberResponse), nil
}
}
//删除云服务器指定元数据。
func (c *EcsClient) DeleteServerMetadata(request *model.DeleteServerMetadataRequest) (*model.DeleteServerMetadataResponse, error) {
requestDef := GenReqDefForDeleteServerMetadata(request)
resp, responseDef := GenRespForDeleteServerMetadata()
requestDef := GenReqDefForDeleteServerMetadata()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteServerMetadataResponse), nil
}
}
//根据指定的云服务器ID列表，删除云服务器。 系统支持删除单台云服务器和批量删除多台云服务器操作，批量删除云服务器时，一次最多可以删除1000台。
func (c *EcsClient) DeleteServers(request *model.DeleteServersRequest) (*model.DeleteServersResponse, error) {
requestDef := GenReqDefForDeleteServers(request)
resp, responseDef := GenRespForDeleteServers()
requestDef := GenReqDefForDeleteServers()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DeleteServersResponse), nil
}
}
//从弹性云服务器中卸载磁盘。
func (c *EcsClient) DetachServerVolume(request *model.DetachServerVolumeRequest) (*model.DetachServerVolumeResponse, error) {
requestDef := GenReqDefForDetachServerVolume(request)
resp, responseDef := GenRespForDetachServerVolume()
requestDef := GenReqDefForDetachServerVolume()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.DetachServerVolumeResponse), nil
}
}
//查询云服务器规格详情信息和规格扩展信息列表。
func (c *EcsClient) ListFlavors(request *model.ListFlavorsRequest) (*model.ListFlavorsResponse, error) {
requestDef := GenReqDefForListFlavors(request)
resp, responseDef := GenRespForListFlavors()
requestDef := GenReqDefForListFlavors()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListFlavorsResponse), nil
}
}
//变更规格时，部分规格的云服务器之间不能互相变更。您可以通过本接口，通过指定弹性云服务器规格，查询该规格可以变更的规格列表。
func (c *EcsClient) ListResizeFlavors(request *model.ListResizeFlavorsRequest) (*model.ListResizeFlavorsResponse, error) {
requestDef := GenReqDefForListResizeFlavors(request)
resp, responseDef := GenRespForListResizeFlavors()
requestDef := GenReqDefForListResizeFlavors()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListResizeFlavorsResponse), nil
}
}
//查询弹性云服务器挂载的磁盘信息。
func (c *EcsClient) ListServerBlockDevices(request *model.ListServerBlockDevicesRequest) (*model.ListServerBlockDevicesResponse, error) {
requestDef := GenReqDefForListServerBlockDevices(request)
resp, responseDef := GenRespForListServerBlockDevices()
requestDef := GenReqDefForListServerBlockDevices()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListServerBlockDevicesResponse), nil
}
}
//查询云服务器网卡信息。
func (c *EcsClient) ListServerInterfaces(request *model.ListServerInterfacesRequest) (*model.ListServerInterfacesResponse, error) {
requestDef := GenReqDefForListServerInterfaces(request)
resp, responseDef := GenRespForListServerInterfaces()
requestDef := GenReqDefForListServerInterfaces()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListServerInterfacesResponse), nil
}
}
//根据用户请求条件从数据库筛选、查询所有的弹性云服务器，并关联相关表获取到弹性云服务器的详细信息。 该接口支持查询弹性云服务器计费方式，以及是否被冻结。
func (c *EcsClient) ListServersDetails(request *model.ListServersDetailsRequest) (*model.ListServersDetailsResponse, error) {
requestDef := GenReqDefForListServersDetails(request)
resp, responseDef := GenRespForListServersDetails()
requestDef := GenReqDefForListServersDetails()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ListServersDetailsResponse), nil
}
}
//为弹性云服务器添加一个安全组。 添加多个安全组时，建议最多为弹性云服务器添加5个安全组。
func (c *EcsClient) NovaAssociateSecurityGroup(request *model.NovaAssociateSecurityGroupRequest) (*model.NovaAssociateSecurityGroupResponse, error) {
requestDef := GenReqDefForNovaAssociateSecurityGroup(request)
resp, responseDef := GenRespForNovaAssociateSecurityGroup()
requestDef := GenReqDefForNovaAssociateSecurityGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaAssociateSecurityGroupResponse), nil
}
}
//创建SSH密钥，或把公钥导入系统，生成密钥对。 创建SSH密钥成功后，请把响应数据中的私钥内容保存到本地文件，用户使用该私钥登录云服务器云主机。为保证云服务器云主机器安全，私钥数据只能读取一次，请妥善保管。
func (c *EcsClient) NovaCreateKeypair(request *model.NovaCreateKeypairRequest) (*model.NovaCreateKeypairResponse, error) {
requestDef := GenReqDefForNovaCreateKeypair(request)
resp, responseDef := GenRespForNovaCreateKeypair()
requestDef := GenReqDefForNovaCreateKeypair()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaCreateKeypairResponse), nil
}
}
//创建一台弹性云服务器。 弹性云服务器创建完成后，如需开启自动恢复功能，可以调用配置云服务器自动恢复的接口，具体使用请参见管理云服务器自动恢复动作。 该接口在云服务器创建失败后不支持自动回滚。若需要自动回滚能力，可以调用POST /v1/{project_id}/cloudservers接口，具体使用请参见创建云服务器（按需）。
func (c *EcsClient) NovaCreateServers(request *model.NovaCreateServersRequest) (*model.NovaCreateServersResponse, error) {
requestDef := GenReqDefForNovaCreateServers(request)
resp, responseDef := GenRespForNovaCreateServers()
requestDef := GenReqDefForNovaCreateServers()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaCreateServersResponse), nil
}
}
//根据SSH密钥的名称，删除指定SSH密钥。
func (c *EcsClient) NovaDeleteKeypair(request *model.NovaDeleteKeypairRequest) (*model.NovaDeleteKeypairResponse, error) {
requestDef := GenReqDefForNovaDeleteKeypair(request)
resp, responseDef := GenRespForNovaDeleteKeypair()
requestDef := GenReqDefForNovaDeleteKeypair()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaDeleteKeypairResponse), nil
}
}
//删除一台云服务器。
func (c *EcsClient) NovaDeleteServer(request *model.NovaDeleteServerRequest) (*model.NovaDeleteServerResponse, error) {
requestDef := GenReqDefForNovaDeleteServer(request)
resp, responseDef := GenRespForNovaDeleteServer()
requestDef := GenReqDefForNovaDeleteServer()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaDeleteServerResponse), nil
}
}
//移除弹性云服务器中的安全组。
func (c *EcsClient) NovaDisassociateSecurityGroup(request *model.NovaDisassociateSecurityGroupRequest) (*model.NovaDisassociateSecurityGroupResponse, error) {
requestDef := GenReqDefForNovaDisassociateSecurityGroup(request)
resp, responseDef := GenRespForNovaDisassociateSecurityGroup()
requestDef := GenReqDefForNovaDisassociateSecurityGroup()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaDisassociateSecurityGroupResponse), nil
}
}
//查询可用域列表。
func (c *EcsClient) NovaListAvailabilityZones(request *model.NovaListAvailabilityZonesRequest) (*model.NovaListAvailabilityZonesResponse, error) {
requestDef := GenReqDefForNovaListAvailabilityZones(request)
resp, responseDef := GenRespForNovaListAvailabilityZones()
requestDef := GenReqDefForNovaListAvailabilityZones()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaListAvailabilityZonesResponse), nil
}
}
//查询SSH密钥信息列表。
func (c *EcsClient) NovaListKeypairs(request *model.NovaListKeypairsRequest) (*model.NovaListKeypairsResponse, error) {
requestDef := GenReqDefForNovaListKeypairs(request)
resp, responseDef := GenRespForNovaListKeypairs()
requestDef := GenReqDefForNovaListKeypairs()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaListKeypairsResponse), nil
}
}
//查询指定弹性云服务器的安全组。
func (c *EcsClient) NovaListServerSecurityGroups(request *model.NovaListServerSecurityGroupsRequest) (*model.NovaListServerSecurityGroupsResponse, error) {
requestDef := GenReqDefForNovaListServerSecurityGroups(request)
resp, responseDef := GenRespForNovaListServerSecurityGroups()
requestDef := GenReqDefForNovaListServerSecurityGroups()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaListServerSecurityGroupsResponse), nil
}
}
//查询云服务器详情信息列表。
func (c *EcsClient) NovaListServersDetails(request *model.NovaListServersDetailsRequest) (*model.NovaListServersDetailsResponse, error) {
requestDef := GenReqDefForNovaListServersDetails(request)
resp, responseDef := GenRespForNovaListServersDetails()
requestDef := GenReqDefForNovaListServersDetails()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaListServersDetailsResponse), nil
}
}
//根据云服务器ID，查询云服务器的详细信息。
func (c *EcsClient) NovaShowServer(request *model.NovaShowServerRequest) (*model.NovaShowServerResponse, error) {
requestDef := GenReqDefForNovaShowServer(request)
resp, responseDef := GenRespForNovaShowServer()
requestDef := GenReqDefForNovaShowServer()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.NovaShowServerResponse), nil
}
}
//重装弹性云服务器的操作系统。支持弹性云服务器数据盘不变的情况下，使用原镜像重装系统盘。 调用该接口后，系统将卸载系统盘，然后使用原镜像重新创建系统盘，并挂载至弹性云服务器，实现重装操作系统功能。
func (c *EcsClient) ReinstallServerWithCloudInit(request *model.ReinstallServerWithCloudInitRequest) (*model.ReinstallServerWithCloudInitResponse, error) {
requestDef := GenReqDefForReinstallServerWithCloudInit(request)
resp, responseDef := GenRespForReinstallServerWithCloudInit()
requestDef := GenReqDefForReinstallServerWithCloudInit()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ReinstallServerWithCloudInitResponse), nil
}
}
//重置弹性云服务器管理帐号（root用户或Administrator用户）的密码。
func (c *EcsClient) ResetServerPassword(request *model.ResetServerPasswordRequest) (*model.ResetServerPasswordResponse, error) {
requestDef := GenReqDefForResetServerPassword(request)
resp, responseDef := GenRespForResetServerPassword()
requestDef := GenReqDefForResetServerPassword()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ResetServerPasswordResponse), nil
}
}
//当您创建的弹性云服务器规格无法满足业务需要时，可以变更云服务器规格，升级vCPU、内存。具体接口的使用，请参见本节内容。 变更规格时，部分规格的云服务器之间不能互相变更。 您可以通过接口“/v1/{project_id}/cloudservers/resize_flavors?{instance_uuid,source_flavor_id,source_flavor_name}”查询支持列表。
func (c *EcsClient) ResizePostPaidServer(request *model.ResizePostPaidServerRequest) (*model.ResizePostPaidServerResponse, error) {
requestDef := GenReqDefForResizePostPaidServer(request)
resp, responseDef := GenRespForResizePostPaidServer()
requestDef := GenReqDefForResizePostPaidServer()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ResizePostPaidServerResponse), nil
}
}
//变更云服务器规格。 v1.1版本：指该接口兼容v1接口的功能，同时合入新功能，支持变更包年/包月弹性云服务器的规格。 注意事项： - 该接口可以使用合作伙伴自身的AK/SK或者token调用，也可以用合作伙伴子客户的AK/SK或者token来调用。 - 如果使用AK/SK认证方式，示例代码中region请参考[地区和终端节点](https://developer.huaweicloud.com/endpoint)中“弹性云服务 ECS”下“区域”的内容，，serviceName（英文服务名称缩写）请指定为ECS。 - Endpoint请参考[地区和终端节点](https://developer.huaweicloud.com/endpoint)中“弹性云服务 ECS”下“终端节点（Endpoint）”的内容。
func (c *EcsClient) ResizeServer(request *model.ResizeServerRequest) (*model.ResizeServerResponse, error) {
requestDef := GenReqDefForResizeServer(request)
resp, responseDef := GenRespForResizeServer()
requestDef := GenReqDefForResizeServer()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ResizeServerResponse), nil
}
}
//查询弹性云服务器是否支持一键重置密码。
func (c *EcsClient) ShowResetPasswordFlag(request *model.ShowResetPasswordFlagRequest) (*model.ShowResetPasswordFlagResponse, error) {
requestDef := GenReqDefForShowResetPasswordFlag(request)
resp, responseDef := GenRespForShowResetPasswordFlag()
requestDef := GenReqDefForShowResetPasswordFlag()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowResetPasswordFlagResponse), nil
}
}
//查询弹性云服务器的详细信息。 该接口支持查询弹性云服务器的计费方式，以及是否被冻结。
func (c *EcsClient) ShowServer(request *model.ShowServerRequest) (*model.ShowServerResponse, error) {
requestDef := GenReqDefForShowServer(request)
resp, responseDef := GenRespForShowServer()
requestDef := GenReqDefForShowServer()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowServerResponse), nil
}
}
//查询租户配额信息。
func (c *EcsClient) ShowServerLimits(request *model.ShowServerLimitsRequest) (*model.ShowServerLimitsResponse, error) {
requestDef := GenReqDefForShowServerLimits(request)
resp, responseDef := GenRespForShowServerLimits()
requestDef := GenReqDefForShowServerLimits()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowServerLimitsResponse), nil
}
}
//获取弹性云服务器VNC远程登录地址。
func (c *EcsClient) ShowServerRemoteConsole(request *model.ShowServerRemoteConsoleRequest) (*model.ShowServerRemoteConsoleResponse, error) {
requestDef := GenReqDefForShowServerRemoteConsole(request)
resp, responseDef := GenRespForShowServerRemoteConsole()
requestDef := GenReqDefForShowServerRemoteConsole()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowServerRemoteConsoleResponse), nil
}
}
//- 查询指定云服务器的标签信息。 - 标签管理服务TMS使用该接口查询指定云服务器的全部标签数据。
func (c *EcsClient) ShowServerTags(request *model.ShowServerTagsRequest) (*model.ShowServerTagsResponse, error) {
requestDef := GenReqDefForShowServerTags(request)
resp, responseDef := GenRespForShowServerTags()
requestDef := GenReqDefForShowServerTags()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowServerTagsResponse), nil
}
}
//修改云服务器信息，目前支持修改云服务器名称及描述和hostname。
func (c *EcsClient) UpdateServer(request *model.UpdateServerRequest) (*model.UpdateServerResponse, error) {
requestDef := GenReqDefForUpdateServer(request)
resp, responseDef := GenRespForUpdateServer()
requestDef := GenReqDefForUpdateServer()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.UpdateServerResponse), nil
}
}
//更新云服务器元数据。 - 如果元数据中没有待更新字段，则自动添加该字段。 - 如果元数据中已存在待更新字段，则直接更新字段值。 - 如果元数据中的字段不再请求参数中，则保持不变
func (c *EcsClient) UpdateServerMetadata(request *model.UpdateServerMetadataRequest) (*model.UpdateServerMetadataResponse, error) {
requestDef := GenReqDefForUpdateServerMetadata(request)
resp, responseDef := GenRespForUpdateServerMetadata()
requestDef := GenReqDefForUpdateServerMetadata()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.UpdateServerMetadataResponse), nil
}
}
//查询Job的执行状态。 对于创建云服务器、删除云服务器、云服务器批量操作和网卡操作等异步API，命令下发后，会返回job_id，通过job_id可以查询任务的执行状态。
func (c *EcsClient) ShowJob(request *model.ShowJobRequest) (*model.ShowJobResponse, error) {
requestDef := GenReqDefForShowJob(request)
resp, responseDef := GenRespForShowJob()
requestDef := GenReqDefForShowJob()
if _, err := c.hcClient.Sync(request, requestDef, responseDef); err != nil {
if resp, err := c.hcClient.Sync(request, requestDef); err != nil {
return nil, err
} else {
return resp, nil
return resp.(*model.ShowJobResponse), nil
}
}

1208
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3/services/ecs/v2/ecs_meta.go
View File

File diff suppressed because it is too large Load Diff

4
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud_cloud_provider.go
View File

@ -121,8 +121,8 @@ func (hcp *huaweicloudCloudProvider) NodeGroupForNode(node *apiv1.Node) (cloudpr
return nil, err
}
for i := range instances {
if instanceID == instances[i].Id {
for j := range instances {
if instanceID == instances[j].Id {
pinnedGroup := hcp.autoScalingGroup[i]
return &pinnedGroup, nil
}

9
cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud_service_manager.go
View File

@ -179,6 +179,11 @@ func (csm *cloudServiceManager) GetInstances(groupID string) ([]cloudprovider.In
instances := make([]cloudprovider.Instance, 0, len(*response.ScalingGroupInstances))
for _, sgi := range *response.ScalingGroupInstances {
// When a new instance joining to the scaling group, the instance id maybe empty(nil).
if sgi.InstanceId == nil {
klog.Infof("ignore instance without instance id, maybe instance is joining.")
continue
}
instance := cloudprovider.Instance{
Id: *sgi.InstanceId,
Status: csm.transformInstanceState(*sgi.LifeCycleState, *sgi.HealthStatus),
@ -266,9 +271,9 @@ func (csm *cloudServiceManager) ListScalingGroups() ([]AutoScalingGroup, error)
return nil, fmt.Errorf("failed to list scaling groups due to can not get as client")
}
requiredState := huaweicloudsdkasmodel.GetListScalingGroupsRequestScalingGroupStatusEnum().INSERVICE
// requiredState := huaweicloudsdkasmodel.GetListScalingGroupsRequestScalingGroupStatusEnum().INSERVICE
opts := &huaweicloudsdkasmodel.ListScalingGroupsRequest{
ScalingGroupStatus: &requiredState,
// ScalingGroupStatus: &requiredState,
}
response, err := asClient.ListScalingGroups(opts)
if err != nil {