2760 lines
69 KiB
Go
2760 lines
69 KiB
Go
//
|
|
// Copyright 2016, Sander van Harmelen
|
|
//
|
|
// Licensed 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 cloudstack
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type CreateCounterParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *CreateCounterParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["name"]; found {
|
|
u.Set("name", v.(string))
|
|
}
|
|
if v, found := p.p["source"]; found {
|
|
u.Set("source", v.(string))
|
|
}
|
|
if v, found := p.p["value"]; found {
|
|
u.Set("value", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *CreateCounterParams) SetName(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["name"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateCounterParams) SetSource(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["source"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateCounterParams) SetValue(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["value"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new CreateCounterParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewCreateCounterParams(name string, source string, value string) *CreateCounterParams {
|
|
p := &CreateCounterParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["name"] = name
|
|
p.p["source"] = source
|
|
p.p["value"] = value
|
|
return p
|
|
}
|
|
|
|
// Adds metric counter
|
|
func (s *AutoScaleService) CreateCounter(p *CreateCounterParams) (*CreateCounterResponse, error) {
|
|
resp, err := s.cs.newRequest("createCounter", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r CreateCounterResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type CreateCounterResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Name string `json:"name,omitempty"`
|
|
Source string `json:"source,omitempty"`
|
|
Value string `json:"value,omitempty"`
|
|
Zoneid string `json:"zoneid,omitempty"`
|
|
}
|
|
|
|
type CreateConditionParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *CreateConditionParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["account"]; found {
|
|
u.Set("account", v.(string))
|
|
}
|
|
if v, found := p.p["counterid"]; found {
|
|
u.Set("counterid", v.(string))
|
|
}
|
|
if v, found := p.p["domainid"]; found {
|
|
u.Set("domainid", v.(string))
|
|
}
|
|
if v, found := p.p["relationaloperator"]; found {
|
|
u.Set("relationaloperator", v.(string))
|
|
}
|
|
if v, found := p.p["threshold"]; found {
|
|
vv := strconv.FormatInt(v.(int64), 10)
|
|
u.Set("threshold", vv)
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *CreateConditionParams) SetAccount(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["account"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateConditionParams) SetCounterid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["counterid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateConditionParams) SetDomainid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["domainid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateConditionParams) SetRelationaloperator(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["relationaloperator"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateConditionParams) SetThreshold(v int64) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["threshold"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new CreateConditionParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewCreateConditionParams(counterid string, relationaloperator string, threshold int64) *CreateConditionParams {
|
|
p := &CreateConditionParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["counterid"] = counterid
|
|
p.p["relationaloperator"] = relationaloperator
|
|
p.p["threshold"] = threshold
|
|
return p
|
|
}
|
|
|
|
// Creates a condition
|
|
func (s *AutoScaleService) CreateCondition(p *CreateConditionParams) (*CreateConditionResponse, error) {
|
|
resp, err := s.cs.newRequest("createCondition", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r CreateConditionResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type CreateConditionResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Counter []string `json:"counter,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Relationaloperator string `json:"relationaloperator,omitempty"`
|
|
Threshold int64 `json:"threshold,omitempty"`
|
|
Zoneid string `json:"zoneid,omitempty"`
|
|
}
|
|
|
|
type CreateAutoScalePolicyParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *CreateAutoScalePolicyParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["action"]; found {
|
|
u.Set("action", v.(string))
|
|
}
|
|
if v, found := p.p["conditionids"]; found {
|
|
vv := strings.Join(v.([]string), ",")
|
|
u.Set("conditionids", vv)
|
|
}
|
|
if v, found := p.p["duration"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("duration", vv)
|
|
}
|
|
if v, found := p.p["quiettime"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("quiettime", vv)
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *CreateAutoScalePolicyParams) SetAction(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["action"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScalePolicyParams) SetConditionids(v []string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["conditionids"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScalePolicyParams) SetDuration(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["duration"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScalePolicyParams) SetQuiettime(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["quiettime"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new CreateAutoScalePolicyParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewCreateAutoScalePolicyParams(action string, conditionids []string, duration int) *CreateAutoScalePolicyParams {
|
|
p := &CreateAutoScalePolicyParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["action"] = action
|
|
p.p["conditionids"] = conditionids
|
|
p.p["duration"] = duration
|
|
return p
|
|
}
|
|
|
|
// Creates an autoscale policy for a provision or deprovision action, the action is taken when the all the conditions evaluates to true for the specified duration. The policy is in effect once it is attached to a autscale vm group.
|
|
func (s *AutoScaleService) CreateAutoScalePolicy(p *CreateAutoScalePolicyParams) (*CreateAutoScalePolicyResponse, error) {
|
|
resp, err := s.cs.newRequest("createAutoScalePolicy", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r CreateAutoScalePolicyResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type CreateAutoScalePolicyResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Action string `json:"action,omitempty"`
|
|
Conditions []string `json:"conditions,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Duration int `json:"duration,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Quiettime int `json:"quiettime,omitempty"`
|
|
}
|
|
|
|
type CreateAutoScaleVmProfileParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["autoscaleuserid"]; found {
|
|
u.Set("autoscaleuserid", v.(string))
|
|
}
|
|
if v, found := p.p["counterparam"]; found {
|
|
i := 0
|
|
for k, vv := range v.(map[string]string) {
|
|
u.Set(fmt.Sprintf("counterparam[%d].key", i), k)
|
|
u.Set(fmt.Sprintf("counterparam[%d].value", i), vv)
|
|
i++
|
|
}
|
|
}
|
|
if v, found := p.p["destroyvmgraceperiod"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("destroyvmgraceperiod", vv)
|
|
}
|
|
if v, found := p.p["fordisplay"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("fordisplay", vv)
|
|
}
|
|
if v, found := p.p["otherdeployparams"]; found {
|
|
u.Set("otherdeployparams", v.(string))
|
|
}
|
|
if v, found := p.p["serviceofferingid"]; found {
|
|
u.Set("serviceofferingid", v.(string))
|
|
}
|
|
if v, found := p.p["templateid"]; found {
|
|
u.Set("templateid", v.(string))
|
|
}
|
|
if v, found := p.p["zoneid"]; found {
|
|
u.Set("zoneid", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) SetAutoscaleuserid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["autoscaleuserid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) SetCounterparam(v map[string]string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["counterparam"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) SetDestroyvmgraceperiod(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["destroyvmgraceperiod"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) SetFordisplay(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["fordisplay"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) SetOtherdeployparams(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["otherdeployparams"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) SetServiceofferingid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["serviceofferingid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) SetTemplateid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["templateid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmProfileParams) SetZoneid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["zoneid"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new CreateAutoScaleVmProfileParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewCreateAutoScaleVmProfileParams(serviceofferingid string, templateid string, zoneid string) *CreateAutoScaleVmProfileParams {
|
|
p := &CreateAutoScaleVmProfileParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["serviceofferingid"] = serviceofferingid
|
|
p.p["templateid"] = templateid
|
|
p.p["zoneid"] = zoneid
|
|
return p
|
|
}
|
|
|
|
// Creates a profile that contains information about the virtual machine which will be provisioned automatically by autoscale feature.
|
|
func (s *AutoScaleService) CreateAutoScaleVmProfile(p *CreateAutoScaleVmProfileParams) (*CreateAutoScaleVmProfileResponse, error) {
|
|
resp, err := s.cs.newRequest("createAutoScaleVmProfile", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r CreateAutoScaleVmProfileResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type CreateAutoScaleVmProfileResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Autoscaleuserid string `json:"autoscaleuserid,omitempty"`
|
|
Destroyvmgraceperiod int `json:"destroyvmgraceperiod,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Fordisplay bool `json:"fordisplay,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Otherdeployparams string `json:"otherdeployparams,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Serviceofferingid string `json:"serviceofferingid,omitempty"`
|
|
Templateid string `json:"templateid,omitempty"`
|
|
Zoneid string `json:"zoneid,omitempty"`
|
|
}
|
|
|
|
type CreateAutoScaleVmGroupParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["fordisplay"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("fordisplay", vv)
|
|
}
|
|
if v, found := p.p["interval"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("interval", vv)
|
|
}
|
|
if v, found := p.p["lbruleid"]; found {
|
|
u.Set("lbruleid", v.(string))
|
|
}
|
|
if v, found := p.p["maxmembers"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("maxmembers", vv)
|
|
}
|
|
if v, found := p.p["minmembers"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("minmembers", vv)
|
|
}
|
|
if v, found := p.p["scaledownpolicyids"]; found {
|
|
vv := strings.Join(v.([]string), ",")
|
|
u.Set("scaledownpolicyids", vv)
|
|
}
|
|
if v, found := p.p["scaleuppolicyids"]; found {
|
|
vv := strings.Join(v.([]string), ",")
|
|
u.Set("scaleuppolicyids", vv)
|
|
}
|
|
if v, found := p.p["vmprofileid"]; found {
|
|
u.Set("vmprofileid", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) SetFordisplay(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["fordisplay"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) SetInterval(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["interval"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) SetLbruleid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["lbruleid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) SetMaxmembers(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["maxmembers"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) SetMinmembers(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["minmembers"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) SetScaledownpolicyids(v []string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["scaledownpolicyids"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) SetScaleuppolicyids(v []string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["scaleuppolicyids"] = v
|
|
return
|
|
}
|
|
|
|
func (p *CreateAutoScaleVmGroupParams) SetVmprofileid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["vmprofileid"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new CreateAutoScaleVmGroupParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewCreateAutoScaleVmGroupParams(lbruleid string, maxmembers int, minmembers int, scaledownpolicyids []string, scaleuppolicyids []string, vmprofileid string) *CreateAutoScaleVmGroupParams {
|
|
p := &CreateAutoScaleVmGroupParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["lbruleid"] = lbruleid
|
|
p.p["maxmembers"] = maxmembers
|
|
p.p["minmembers"] = minmembers
|
|
p.p["scaledownpolicyids"] = scaledownpolicyids
|
|
p.p["scaleuppolicyids"] = scaleuppolicyids
|
|
p.p["vmprofileid"] = vmprofileid
|
|
return p
|
|
}
|
|
|
|
// Creates and automatically starts a virtual machine based on a service offering, disk offering, and template.
|
|
func (s *AutoScaleService) CreateAutoScaleVmGroup(p *CreateAutoScaleVmGroupParams) (*CreateAutoScaleVmGroupResponse, error) {
|
|
resp, err := s.cs.newRequest("createAutoScaleVmGroup", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r CreateAutoScaleVmGroupResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type CreateAutoScaleVmGroupResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Fordisplay bool `json:"fordisplay,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Interval int `json:"interval,omitempty"`
|
|
Lbruleid string `json:"lbruleid,omitempty"`
|
|
Maxmembers int `json:"maxmembers,omitempty"`
|
|
Minmembers int `json:"minmembers,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Scaledownpolicies []string `json:"scaledownpolicies,omitempty"`
|
|
Scaleuppolicies []string `json:"scaleuppolicies,omitempty"`
|
|
State string `json:"state,omitempty"`
|
|
Vmprofileid string `json:"vmprofileid,omitempty"`
|
|
}
|
|
|
|
type DeleteCounterParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *DeleteCounterParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *DeleteCounterParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new DeleteCounterParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewDeleteCounterParams(id string) *DeleteCounterParams {
|
|
p := &DeleteCounterParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Deletes a counter
|
|
func (s *AutoScaleService) DeleteCounter(p *DeleteCounterParams) (*DeleteCounterResponse, error) {
|
|
resp, err := s.cs.newRequest("deleteCounter", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r DeleteCounterResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type DeleteCounterResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Displaytext string `json:"displaytext,omitempty"`
|
|
Success bool `json:"success,omitempty"`
|
|
}
|
|
|
|
type DeleteConditionParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *DeleteConditionParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *DeleteConditionParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new DeleteConditionParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewDeleteConditionParams(id string) *DeleteConditionParams {
|
|
p := &DeleteConditionParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Removes a condition
|
|
func (s *AutoScaleService) DeleteCondition(p *DeleteConditionParams) (*DeleteConditionResponse, error) {
|
|
resp, err := s.cs.newRequest("deleteCondition", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r DeleteConditionResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type DeleteConditionResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Displaytext string `json:"displaytext,omitempty"`
|
|
Success bool `json:"success,omitempty"`
|
|
}
|
|
|
|
type DeleteAutoScalePolicyParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *DeleteAutoScalePolicyParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *DeleteAutoScalePolicyParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new DeleteAutoScalePolicyParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewDeleteAutoScalePolicyParams(id string) *DeleteAutoScalePolicyParams {
|
|
p := &DeleteAutoScalePolicyParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Deletes a autoscale policy.
|
|
func (s *AutoScaleService) DeleteAutoScalePolicy(p *DeleteAutoScalePolicyParams) (*DeleteAutoScalePolicyResponse, error) {
|
|
resp, err := s.cs.newRequest("deleteAutoScalePolicy", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r DeleteAutoScalePolicyResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type DeleteAutoScalePolicyResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Displaytext string `json:"displaytext,omitempty"`
|
|
Success bool `json:"success,omitempty"`
|
|
}
|
|
|
|
type DeleteAutoScaleVmProfileParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *DeleteAutoScaleVmProfileParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *DeleteAutoScaleVmProfileParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new DeleteAutoScaleVmProfileParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewDeleteAutoScaleVmProfileParams(id string) *DeleteAutoScaleVmProfileParams {
|
|
p := &DeleteAutoScaleVmProfileParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Deletes a autoscale vm profile.
|
|
func (s *AutoScaleService) DeleteAutoScaleVmProfile(p *DeleteAutoScaleVmProfileParams) (*DeleteAutoScaleVmProfileResponse, error) {
|
|
resp, err := s.cs.newRequest("deleteAutoScaleVmProfile", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r DeleteAutoScaleVmProfileResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type DeleteAutoScaleVmProfileResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Displaytext string `json:"displaytext,omitempty"`
|
|
Success bool `json:"success,omitempty"`
|
|
}
|
|
|
|
type DeleteAutoScaleVmGroupParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *DeleteAutoScaleVmGroupParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *DeleteAutoScaleVmGroupParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new DeleteAutoScaleVmGroupParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewDeleteAutoScaleVmGroupParams(id string) *DeleteAutoScaleVmGroupParams {
|
|
p := &DeleteAutoScaleVmGroupParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Deletes a autoscale vm group.
|
|
func (s *AutoScaleService) DeleteAutoScaleVmGroup(p *DeleteAutoScaleVmGroupParams) (*DeleteAutoScaleVmGroupResponse, error) {
|
|
resp, err := s.cs.newRequest("deleteAutoScaleVmGroup", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r DeleteAutoScaleVmGroupResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type DeleteAutoScaleVmGroupResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Displaytext string `json:"displaytext,omitempty"`
|
|
Success bool `json:"success,omitempty"`
|
|
}
|
|
|
|
type ListCountersParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *ListCountersParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
if v, found := p.p["keyword"]; found {
|
|
u.Set("keyword", v.(string))
|
|
}
|
|
if v, found := p.p["name"]; found {
|
|
u.Set("name", v.(string))
|
|
}
|
|
if v, found := p.p["page"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("page", vv)
|
|
}
|
|
if v, found := p.p["pagesize"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("pagesize", vv)
|
|
}
|
|
if v, found := p.p["source"]; found {
|
|
u.Set("source", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *ListCountersParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListCountersParams) SetKeyword(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["keyword"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListCountersParams) SetName(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["name"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListCountersParams) SetPage(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["page"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListCountersParams) SetPagesize(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["pagesize"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListCountersParams) SetSource(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["source"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new ListCountersParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewListCountersParams() *ListCountersParams {
|
|
p := &ListCountersParams{}
|
|
p.p = make(map[string]interface{})
|
|
return p
|
|
}
|
|
|
|
// This is a courtesy helper function, which in some cases may not work as expected!
|
|
func (s *AutoScaleService) GetCounterID(name string, opts ...OptionFunc) (string, int, error) {
|
|
p := &ListCountersParams{}
|
|
p.p = make(map[string]interface{})
|
|
|
|
p.p["name"] = name
|
|
|
|
for _, fn := range opts {
|
|
if err := fn(s.cs, p); err != nil {
|
|
return "", -1, err
|
|
}
|
|
}
|
|
|
|
l, err := s.ListCounters(p)
|
|
if err != nil {
|
|
return "", -1, err
|
|
}
|
|
|
|
if l.Count == 0 {
|
|
return "", l.Count, fmt.Errorf("No match found for %s: %+v", name, l)
|
|
}
|
|
|
|
if l.Count == 1 {
|
|
return l.Counters[0].Id, l.Count, nil
|
|
}
|
|
|
|
if l.Count > 1 {
|
|
for _, v := range l.Counters {
|
|
if v.Name == name {
|
|
return v.Id, l.Count, nil
|
|
}
|
|
}
|
|
}
|
|
return "", l.Count, fmt.Errorf("Could not find an exact match for %s: %+v", name, l)
|
|
}
|
|
|
|
// This is a courtesy helper function, which in some cases may not work as expected!
|
|
func (s *AutoScaleService) GetCounterByName(name string, opts ...OptionFunc) (*Counter, int, error) {
|
|
id, count, err := s.GetCounterID(name, opts...)
|
|
if err != nil {
|
|
return nil, count, err
|
|
}
|
|
|
|
r, count, err := s.GetCounterByID(id, opts...)
|
|
if err != nil {
|
|
return nil, count, err
|
|
}
|
|
return r, count, nil
|
|
}
|
|
|
|
// This is a courtesy helper function, which in some cases may not work as expected!
|
|
func (s *AutoScaleService) GetCounterByID(id string, opts ...OptionFunc) (*Counter, int, error) {
|
|
p := &ListCountersParams{}
|
|
p.p = make(map[string]interface{})
|
|
|
|
p.p["id"] = id
|
|
|
|
for _, fn := range opts {
|
|
if err := fn(s.cs, p); err != nil {
|
|
return nil, -1, err
|
|
}
|
|
}
|
|
|
|
l, err := s.ListCounters(p)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), fmt.Sprintf(
|
|
"Invalid parameter id value=%s due to incorrect long value format, "+
|
|
"or entity does not exist", id)) {
|
|
return nil, 0, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
return nil, -1, err
|
|
}
|
|
|
|
if l.Count == 0 {
|
|
return nil, l.Count, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
|
|
if l.Count == 1 {
|
|
return l.Counters[0], l.Count, nil
|
|
}
|
|
return nil, l.Count, fmt.Errorf("There is more then one result for Counter UUID: %s!", id)
|
|
}
|
|
|
|
// List the counters
|
|
func (s *AutoScaleService) ListCounters(p *ListCountersParams) (*ListCountersResponse, error) {
|
|
resp, err := s.cs.newRequest("listCounters", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r ListCountersResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type ListCountersResponse struct {
|
|
Count int `json:"count"`
|
|
Counters []*Counter `json:"counter"`
|
|
}
|
|
|
|
type Counter struct {
|
|
Id string `json:"id,omitempty"`
|
|
Name string `json:"name,omitempty"`
|
|
Source string `json:"source,omitempty"`
|
|
Value string `json:"value,omitempty"`
|
|
Zoneid string `json:"zoneid,omitempty"`
|
|
}
|
|
|
|
type ListConditionsParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *ListConditionsParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["account"]; found {
|
|
u.Set("account", v.(string))
|
|
}
|
|
if v, found := p.p["counterid"]; found {
|
|
u.Set("counterid", v.(string))
|
|
}
|
|
if v, found := p.p["domainid"]; found {
|
|
u.Set("domainid", v.(string))
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
if v, found := p.p["isrecursive"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("isrecursive", vv)
|
|
}
|
|
if v, found := p.p["keyword"]; found {
|
|
u.Set("keyword", v.(string))
|
|
}
|
|
if v, found := p.p["listall"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("listall", vv)
|
|
}
|
|
if v, found := p.p["page"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("page", vv)
|
|
}
|
|
if v, found := p.p["pagesize"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("pagesize", vv)
|
|
}
|
|
if v, found := p.p["policyid"]; found {
|
|
u.Set("policyid", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetAccount(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["account"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetCounterid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["counterid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetDomainid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["domainid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetIsrecursive(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["isrecursive"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetKeyword(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["keyword"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetListall(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["listall"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetPage(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["page"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetPagesize(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["pagesize"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListConditionsParams) SetPolicyid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["policyid"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new ListConditionsParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewListConditionsParams() *ListConditionsParams {
|
|
p := &ListConditionsParams{}
|
|
p.p = make(map[string]interface{})
|
|
return p
|
|
}
|
|
|
|
// This is a courtesy helper function, which in some cases may not work as expected!
|
|
func (s *AutoScaleService) GetConditionByID(id string, opts ...OptionFunc) (*Condition, int, error) {
|
|
p := &ListConditionsParams{}
|
|
p.p = make(map[string]interface{})
|
|
|
|
p.p["id"] = id
|
|
|
|
for _, fn := range opts {
|
|
if err := fn(s.cs, p); err != nil {
|
|
return nil, -1, err
|
|
}
|
|
}
|
|
|
|
l, err := s.ListConditions(p)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), fmt.Sprintf(
|
|
"Invalid parameter id value=%s due to incorrect long value format, "+
|
|
"or entity does not exist", id)) {
|
|
return nil, 0, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
return nil, -1, err
|
|
}
|
|
|
|
if l.Count == 0 {
|
|
return nil, l.Count, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
|
|
if l.Count == 1 {
|
|
return l.Conditions[0], l.Count, nil
|
|
}
|
|
return nil, l.Count, fmt.Errorf("There is more then one result for Condition UUID: %s!", id)
|
|
}
|
|
|
|
// List Conditions for the specific user
|
|
func (s *AutoScaleService) ListConditions(p *ListConditionsParams) (*ListConditionsResponse, error) {
|
|
resp, err := s.cs.newRequest("listConditions", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r ListConditionsResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type ListConditionsResponse struct {
|
|
Count int `json:"count"`
|
|
Conditions []*Condition `json:"condition"`
|
|
}
|
|
|
|
type Condition struct {
|
|
Account string `json:"account,omitempty"`
|
|
Counter []string `json:"counter,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Relationaloperator string `json:"relationaloperator,omitempty"`
|
|
Threshold int64 `json:"threshold,omitempty"`
|
|
Zoneid string `json:"zoneid,omitempty"`
|
|
}
|
|
|
|
type ListAutoScalePoliciesParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["account"]; found {
|
|
u.Set("account", v.(string))
|
|
}
|
|
if v, found := p.p["action"]; found {
|
|
u.Set("action", v.(string))
|
|
}
|
|
if v, found := p.p["conditionid"]; found {
|
|
u.Set("conditionid", v.(string))
|
|
}
|
|
if v, found := p.p["domainid"]; found {
|
|
u.Set("domainid", v.(string))
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
if v, found := p.p["isrecursive"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("isrecursive", vv)
|
|
}
|
|
if v, found := p.p["keyword"]; found {
|
|
u.Set("keyword", v.(string))
|
|
}
|
|
if v, found := p.p["listall"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("listall", vv)
|
|
}
|
|
if v, found := p.p["page"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("page", vv)
|
|
}
|
|
if v, found := p.p["pagesize"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("pagesize", vv)
|
|
}
|
|
if v, found := p.p["vmgroupid"]; found {
|
|
u.Set("vmgroupid", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetAccount(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["account"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetAction(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["action"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetConditionid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["conditionid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetDomainid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["domainid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetIsrecursive(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["isrecursive"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetKeyword(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["keyword"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetListall(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["listall"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetPage(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["page"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetPagesize(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["pagesize"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScalePoliciesParams) SetVmgroupid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["vmgroupid"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new ListAutoScalePoliciesParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewListAutoScalePoliciesParams() *ListAutoScalePoliciesParams {
|
|
p := &ListAutoScalePoliciesParams{}
|
|
p.p = make(map[string]interface{})
|
|
return p
|
|
}
|
|
|
|
// This is a courtesy helper function, which in some cases may not work as expected!
|
|
func (s *AutoScaleService) GetAutoScalePolicyByID(id string, opts ...OptionFunc) (*AutoScalePolicy, int, error) {
|
|
p := &ListAutoScalePoliciesParams{}
|
|
p.p = make(map[string]interface{})
|
|
|
|
p.p["id"] = id
|
|
|
|
for _, fn := range opts {
|
|
if err := fn(s.cs, p); err != nil {
|
|
return nil, -1, err
|
|
}
|
|
}
|
|
|
|
l, err := s.ListAutoScalePolicies(p)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), fmt.Sprintf(
|
|
"Invalid parameter id value=%s due to incorrect long value format, "+
|
|
"or entity does not exist", id)) {
|
|
return nil, 0, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
return nil, -1, err
|
|
}
|
|
|
|
if l.Count == 0 {
|
|
return nil, l.Count, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
|
|
if l.Count == 1 {
|
|
return l.AutoScalePolicies[0], l.Count, nil
|
|
}
|
|
return nil, l.Count, fmt.Errorf("There is more then one result for AutoScalePolicy UUID: %s!", id)
|
|
}
|
|
|
|
// Lists autoscale policies.
|
|
func (s *AutoScaleService) ListAutoScalePolicies(p *ListAutoScalePoliciesParams) (*ListAutoScalePoliciesResponse, error) {
|
|
resp, err := s.cs.newRequest("listAutoScalePolicies", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r ListAutoScalePoliciesResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type ListAutoScalePoliciesResponse struct {
|
|
Count int `json:"count"`
|
|
AutoScalePolicies []*AutoScalePolicy `json:"autoscalepolicy"`
|
|
}
|
|
|
|
type AutoScalePolicy struct {
|
|
Account string `json:"account,omitempty"`
|
|
Action string `json:"action,omitempty"`
|
|
Conditions []string `json:"conditions,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Duration int `json:"duration,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Quiettime int `json:"quiettime,omitempty"`
|
|
}
|
|
|
|
type ListAutoScaleVmProfilesParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["account"]; found {
|
|
u.Set("account", v.(string))
|
|
}
|
|
if v, found := p.p["domainid"]; found {
|
|
u.Set("domainid", v.(string))
|
|
}
|
|
if v, found := p.p["fordisplay"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("fordisplay", vv)
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
if v, found := p.p["isrecursive"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("isrecursive", vv)
|
|
}
|
|
if v, found := p.p["keyword"]; found {
|
|
u.Set("keyword", v.(string))
|
|
}
|
|
if v, found := p.p["listall"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("listall", vv)
|
|
}
|
|
if v, found := p.p["otherdeployparams"]; found {
|
|
u.Set("otherdeployparams", v.(string))
|
|
}
|
|
if v, found := p.p["page"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("page", vv)
|
|
}
|
|
if v, found := p.p["pagesize"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("pagesize", vv)
|
|
}
|
|
if v, found := p.p["projectid"]; found {
|
|
u.Set("projectid", v.(string))
|
|
}
|
|
if v, found := p.p["serviceofferingid"]; found {
|
|
u.Set("serviceofferingid", v.(string))
|
|
}
|
|
if v, found := p.p["templateid"]; found {
|
|
u.Set("templateid", v.(string))
|
|
}
|
|
if v, found := p.p["zoneid"]; found {
|
|
u.Set("zoneid", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetAccount(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["account"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetDomainid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["domainid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetFordisplay(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["fordisplay"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetIsrecursive(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["isrecursive"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetKeyword(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["keyword"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetListall(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["listall"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetOtherdeployparams(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["otherdeployparams"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetPage(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["page"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetPagesize(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["pagesize"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetProjectid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["projectid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetServiceofferingid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["serviceofferingid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetTemplateid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["templateid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmProfilesParams) SetZoneid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["zoneid"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new ListAutoScaleVmProfilesParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewListAutoScaleVmProfilesParams() *ListAutoScaleVmProfilesParams {
|
|
p := &ListAutoScaleVmProfilesParams{}
|
|
p.p = make(map[string]interface{})
|
|
return p
|
|
}
|
|
|
|
// This is a courtesy helper function, which in some cases may not work as expected!
|
|
func (s *AutoScaleService) GetAutoScaleVmProfileByID(id string, opts ...OptionFunc) (*AutoScaleVmProfile, int, error) {
|
|
p := &ListAutoScaleVmProfilesParams{}
|
|
p.p = make(map[string]interface{})
|
|
|
|
p.p["id"] = id
|
|
|
|
for _, fn := range opts {
|
|
if err := fn(s.cs, p); err != nil {
|
|
return nil, -1, err
|
|
}
|
|
}
|
|
|
|
l, err := s.ListAutoScaleVmProfiles(p)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), fmt.Sprintf(
|
|
"Invalid parameter id value=%s due to incorrect long value format, "+
|
|
"or entity does not exist", id)) {
|
|
return nil, 0, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
return nil, -1, err
|
|
}
|
|
|
|
if l.Count == 0 {
|
|
return nil, l.Count, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
|
|
if l.Count == 1 {
|
|
return l.AutoScaleVmProfiles[0], l.Count, nil
|
|
}
|
|
return nil, l.Count, fmt.Errorf("There is more then one result for AutoScaleVmProfile UUID: %s!", id)
|
|
}
|
|
|
|
// Lists autoscale vm profiles.
|
|
func (s *AutoScaleService) ListAutoScaleVmProfiles(p *ListAutoScaleVmProfilesParams) (*ListAutoScaleVmProfilesResponse, error) {
|
|
resp, err := s.cs.newRequest("listAutoScaleVmProfiles", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r ListAutoScaleVmProfilesResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type ListAutoScaleVmProfilesResponse struct {
|
|
Count int `json:"count"`
|
|
AutoScaleVmProfiles []*AutoScaleVmProfile `json:"autoscalevmprofile"`
|
|
}
|
|
|
|
type AutoScaleVmProfile struct {
|
|
Account string `json:"account,omitempty"`
|
|
Autoscaleuserid string `json:"autoscaleuserid,omitempty"`
|
|
Destroyvmgraceperiod int `json:"destroyvmgraceperiod,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Fordisplay bool `json:"fordisplay,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Otherdeployparams string `json:"otherdeployparams,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Serviceofferingid string `json:"serviceofferingid,omitempty"`
|
|
Templateid string `json:"templateid,omitempty"`
|
|
Zoneid string `json:"zoneid,omitempty"`
|
|
}
|
|
|
|
type ListAutoScaleVmGroupsParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["account"]; found {
|
|
u.Set("account", v.(string))
|
|
}
|
|
if v, found := p.p["domainid"]; found {
|
|
u.Set("domainid", v.(string))
|
|
}
|
|
if v, found := p.p["fordisplay"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("fordisplay", vv)
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
if v, found := p.p["isrecursive"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("isrecursive", vv)
|
|
}
|
|
if v, found := p.p["keyword"]; found {
|
|
u.Set("keyword", v.(string))
|
|
}
|
|
if v, found := p.p["lbruleid"]; found {
|
|
u.Set("lbruleid", v.(string))
|
|
}
|
|
if v, found := p.p["listall"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("listall", vv)
|
|
}
|
|
if v, found := p.p["page"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("page", vv)
|
|
}
|
|
if v, found := p.p["pagesize"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("pagesize", vv)
|
|
}
|
|
if v, found := p.p["policyid"]; found {
|
|
u.Set("policyid", v.(string))
|
|
}
|
|
if v, found := p.p["projectid"]; found {
|
|
u.Set("projectid", v.(string))
|
|
}
|
|
if v, found := p.p["vmprofileid"]; found {
|
|
u.Set("vmprofileid", v.(string))
|
|
}
|
|
if v, found := p.p["zoneid"]; found {
|
|
u.Set("zoneid", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetAccount(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["account"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetDomainid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["domainid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetFordisplay(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["fordisplay"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetIsrecursive(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["isrecursive"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetKeyword(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["keyword"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetLbruleid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["lbruleid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetListall(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["listall"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetPage(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["page"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetPagesize(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["pagesize"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetPolicyid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["policyid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetProjectid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["projectid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetVmprofileid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["vmprofileid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *ListAutoScaleVmGroupsParams) SetZoneid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["zoneid"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new ListAutoScaleVmGroupsParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewListAutoScaleVmGroupsParams() *ListAutoScaleVmGroupsParams {
|
|
p := &ListAutoScaleVmGroupsParams{}
|
|
p.p = make(map[string]interface{})
|
|
return p
|
|
}
|
|
|
|
// This is a courtesy helper function, which in some cases may not work as expected!
|
|
func (s *AutoScaleService) GetAutoScaleVmGroupByID(id string, opts ...OptionFunc) (*AutoScaleVmGroup, int, error) {
|
|
p := &ListAutoScaleVmGroupsParams{}
|
|
p.p = make(map[string]interface{})
|
|
|
|
p.p["id"] = id
|
|
|
|
for _, fn := range opts {
|
|
if err := fn(s.cs, p); err != nil {
|
|
return nil, -1, err
|
|
}
|
|
}
|
|
|
|
l, err := s.ListAutoScaleVmGroups(p)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), fmt.Sprintf(
|
|
"Invalid parameter id value=%s due to incorrect long value format, "+
|
|
"or entity does not exist", id)) {
|
|
return nil, 0, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
return nil, -1, err
|
|
}
|
|
|
|
if l.Count == 0 {
|
|
return nil, l.Count, fmt.Errorf("No match found for %s: %+v", id, l)
|
|
}
|
|
|
|
if l.Count == 1 {
|
|
return l.AutoScaleVmGroups[0], l.Count, nil
|
|
}
|
|
return nil, l.Count, fmt.Errorf("There is more then one result for AutoScaleVmGroup UUID: %s!", id)
|
|
}
|
|
|
|
// Lists autoscale vm groups.
|
|
func (s *AutoScaleService) ListAutoScaleVmGroups(p *ListAutoScaleVmGroupsParams) (*ListAutoScaleVmGroupsResponse, error) {
|
|
resp, err := s.cs.newRequest("listAutoScaleVmGroups", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r ListAutoScaleVmGroupsResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type ListAutoScaleVmGroupsResponse struct {
|
|
Count int `json:"count"`
|
|
AutoScaleVmGroups []*AutoScaleVmGroup `json:"autoscalevmgroup"`
|
|
}
|
|
|
|
type AutoScaleVmGroup struct {
|
|
Account string `json:"account,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Fordisplay bool `json:"fordisplay,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Interval int `json:"interval,omitempty"`
|
|
Lbruleid string `json:"lbruleid,omitempty"`
|
|
Maxmembers int `json:"maxmembers,omitempty"`
|
|
Minmembers int `json:"minmembers,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Scaledownpolicies []string `json:"scaledownpolicies,omitempty"`
|
|
Scaleuppolicies []string `json:"scaleuppolicies,omitempty"`
|
|
State string `json:"state,omitempty"`
|
|
Vmprofileid string `json:"vmprofileid,omitempty"`
|
|
}
|
|
|
|
type EnableAutoScaleVmGroupParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *EnableAutoScaleVmGroupParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *EnableAutoScaleVmGroupParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new EnableAutoScaleVmGroupParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewEnableAutoScaleVmGroupParams(id string) *EnableAutoScaleVmGroupParams {
|
|
p := &EnableAutoScaleVmGroupParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Enables an AutoScale Vm Group
|
|
func (s *AutoScaleService) EnableAutoScaleVmGroup(p *EnableAutoScaleVmGroupParams) (*EnableAutoScaleVmGroupResponse, error) {
|
|
resp, err := s.cs.newRequest("enableAutoScaleVmGroup", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r EnableAutoScaleVmGroupResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type EnableAutoScaleVmGroupResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Fordisplay bool `json:"fordisplay,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Interval int `json:"interval,omitempty"`
|
|
Lbruleid string `json:"lbruleid,omitempty"`
|
|
Maxmembers int `json:"maxmembers,omitempty"`
|
|
Minmembers int `json:"minmembers,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Scaledownpolicies []string `json:"scaledownpolicies,omitempty"`
|
|
Scaleuppolicies []string `json:"scaleuppolicies,omitempty"`
|
|
State string `json:"state,omitempty"`
|
|
Vmprofileid string `json:"vmprofileid,omitempty"`
|
|
}
|
|
|
|
type DisableAutoScaleVmGroupParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *DisableAutoScaleVmGroupParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *DisableAutoScaleVmGroupParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new DisableAutoScaleVmGroupParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewDisableAutoScaleVmGroupParams(id string) *DisableAutoScaleVmGroupParams {
|
|
p := &DisableAutoScaleVmGroupParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Disables an AutoScale Vm Group
|
|
func (s *AutoScaleService) DisableAutoScaleVmGroup(p *DisableAutoScaleVmGroupParams) (*DisableAutoScaleVmGroupResponse, error) {
|
|
resp, err := s.cs.newRequest("disableAutoScaleVmGroup", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r DisableAutoScaleVmGroupResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type DisableAutoScaleVmGroupResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Fordisplay bool `json:"fordisplay,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Interval int `json:"interval,omitempty"`
|
|
Lbruleid string `json:"lbruleid,omitempty"`
|
|
Maxmembers int `json:"maxmembers,omitempty"`
|
|
Minmembers int `json:"minmembers,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Scaledownpolicies []string `json:"scaledownpolicies,omitempty"`
|
|
Scaleuppolicies []string `json:"scaleuppolicies,omitempty"`
|
|
State string `json:"state,omitempty"`
|
|
Vmprofileid string `json:"vmprofileid,omitempty"`
|
|
}
|
|
|
|
type UpdateAutoScalePolicyParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *UpdateAutoScalePolicyParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["conditionids"]; found {
|
|
vv := strings.Join(v.([]string), ",")
|
|
u.Set("conditionids", vv)
|
|
}
|
|
if v, found := p.p["duration"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("duration", vv)
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
if v, found := p.p["quiettime"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("quiettime", vv)
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *UpdateAutoScalePolicyParams) SetConditionids(v []string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["conditionids"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScalePolicyParams) SetDuration(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["duration"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScalePolicyParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScalePolicyParams) SetQuiettime(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["quiettime"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new UpdateAutoScalePolicyParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewUpdateAutoScalePolicyParams(id string) *UpdateAutoScalePolicyParams {
|
|
p := &UpdateAutoScalePolicyParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Updates an existing autoscale policy.
|
|
func (s *AutoScaleService) UpdateAutoScalePolicy(p *UpdateAutoScalePolicyParams) (*UpdateAutoScalePolicyResponse, error) {
|
|
resp, err := s.cs.newRequest("updateAutoScalePolicy", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r UpdateAutoScalePolicyResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type UpdateAutoScalePolicyResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Action string `json:"action,omitempty"`
|
|
Conditions []string `json:"conditions,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Duration int `json:"duration,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Quiettime int `json:"quiettime,omitempty"`
|
|
}
|
|
|
|
type UpdateAutoScaleVmProfileParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmProfileParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["autoscaleuserid"]; found {
|
|
u.Set("autoscaleuserid", v.(string))
|
|
}
|
|
if v, found := p.p["counterparam"]; found {
|
|
i := 0
|
|
for k, vv := range v.(map[string]string) {
|
|
u.Set(fmt.Sprintf("counterparam[%d].key", i), k)
|
|
u.Set(fmt.Sprintf("counterparam[%d].value", i), vv)
|
|
i++
|
|
}
|
|
}
|
|
if v, found := p.p["customid"]; found {
|
|
u.Set("customid", v.(string))
|
|
}
|
|
if v, found := p.p["destroyvmgraceperiod"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("destroyvmgraceperiod", vv)
|
|
}
|
|
if v, found := p.p["fordisplay"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("fordisplay", vv)
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
if v, found := p.p["templateid"]; found {
|
|
u.Set("templateid", v.(string))
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmProfileParams) SetAutoscaleuserid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["autoscaleuserid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmProfileParams) SetCounterparam(v map[string]string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["counterparam"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmProfileParams) SetCustomid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["customid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmProfileParams) SetDestroyvmgraceperiod(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["destroyvmgraceperiod"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmProfileParams) SetFordisplay(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["fordisplay"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmProfileParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmProfileParams) SetTemplateid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["templateid"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new UpdateAutoScaleVmProfileParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewUpdateAutoScaleVmProfileParams(id string) *UpdateAutoScaleVmProfileParams {
|
|
p := &UpdateAutoScaleVmProfileParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Updates an existing autoscale vm profile.
|
|
func (s *AutoScaleService) UpdateAutoScaleVmProfile(p *UpdateAutoScaleVmProfileParams) (*UpdateAutoScaleVmProfileResponse, error) {
|
|
resp, err := s.cs.newRequest("updateAutoScaleVmProfile", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r UpdateAutoScaleVmProfileResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type UpdateAutoScaleVmProfileResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Autoscaleuserid string `json:"autoscaleuserid,omitempty"`
|
|
Destroyvmgraceperiod int `json:"destroyvmgraceperiod,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Fordisplay bool `json:"fordisplay,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Otherdeployparams string `json:"otherdeployparams,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Serviceofferingid string `json:"serviceofferingid,omitempty"`
|
|
Templateid string `json:"templateid,omitempty"`
|
|
Zoneid string `json:"zoneid,omitempty"`
|
|
}
|
|
|
|
type UpdateAutoScaleVmGroupParams struct {
|
|
p map[string]interface{}
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) toURLValues() url.Values {
|
|
u := url.Values{}
|
|
if p.p == nil {
|
|
return u
|
|
}
|
|
if v, found := p.p["customid"]; found {
|
|
u.Set("customid", v.(string))
|
|
}
|
|
if v, found := p.p["fordisplay"]; found {
|
|
vv := strconv.FormatBool(v.(bool))
|
|
u.Set("fordisplay", vv)
|
|
}
|
|
if v, found := p.p["id"]; found {
|
|
u.Set("id", v.(string))
|
|
}
|
|
if v, found := p.p["interval"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("interval", vv)
|
|
}
|
|
if v, found := p.p["maxmembers"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("maxmembers", vv)
|
|
}
|
|
if v, found := p.p["minmembers"]; found {
|
|
vv := strconv.Itoa(v.(int))
|
|
u.Set("minmembers", vv)
|
|
}
|
|
if v, found := p.p["scaledownpolicyids"]; found {
|
|
vv := strings.Join(v.([]string), ",")
|
|
u.Set("scaledownpolicyids", vv)
|
|
}
|
|
if v, found := p.p["scaleuppolicyids"]; found {
|
|
vv := strings.Join(v.([]string), ",")
|
|
u.Set("scaleuppolicyids", vv)
|
|
}
|
|
return u
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) SetCustomid(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["customid"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) SetFordisplay(v bool) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["fordisplay"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) SetId(v string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["id"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) SetInterval(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["interval"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) SetMaxmembers(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["maxmembers"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) SetMinmembers(v int) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["minmembers"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) SetScaledownpolicyids(v []string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["scaledownpolicyids"] = v
|
|
return
|
|
}
|
|
|
|
func (p *UpdateAutoScaleVmGroupParams) SetScaleuppolicyids(v []string) {
|
|
if p.p == nil {
|
|
p.p = make(map[string]interface{})
|
|
}
|
|
p.p["scaleuppolicyids"] = v
|
|
return
|
|
}
|
|
|
|
// You should always use this function to get a new UpdateAutoScaleVmGroupParams instance,
|
|
// as then you are sure you have configured all required params
|
|
func (s *AutoScaleService) NewUpdateAutoScaleVmGroupParams(id string) *UpdateAutoScaleVmGroupParams {
|
|
p := &UpdateAutoScaleVmGroupParams{}
|
|
p.p = make(map[string]interface{})
|
|
p.p["id"] = id
|
|
return p
|
|
}
|
|
|
|
// Updates an existing autoscale vm group.
|
|
func (s *AutoScaleService) UpdateAutoScaleVmGroup(p *UpdateAutoScaleVmGroupParams) (*UpdateAutoScaleVmGroupResponse, error) {
|
|
resp, err := s.cs.newRequest("updateAutoScaleVmGroup", p.toURLValues())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var r UpdateAutoScaleVmGroupResponse
|
|
if err := json.Unmarshal(resp, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If we have a async client, we need to wait for the async result
|
|
if s.cs.async {
|
|
b, err := s.cs.GetAsyncJobResult(r.JobID, s.cs.timeout)
|
|
if err != nil {
|
|
if err == AsyncTimeoutErr {
|
|
return &r, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
b, err = getRawValue(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
type UpdateAutoScaleVmGroupResponse struct {
|
|
JobID string `json:"jobid,omitempty"`
|
|
Account string `json:"account,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
Domainid string `json:"domainid,omitempty"`
|
|
Fordisplay bool `json:"fordisplay,omitempty"`
|
|
Id string `json:"id,omitempty"`
|
|
Interval int `json:"interval,omitempty"`
|
|
Lbruleid string `json:"lbruleid,omitempty"`
|
|
Maxmembers int `json:"maxmembers,omitempty"`
|
|
Minmembers int `json:"minmembers,omitempty"`
|
|
Project string `json:"project,omitempty"`
|
|
Projectid string `json:"projectid,omitempty"`
|
|
Scaledownpolicies []string `json:"scaledownpolicies,omitempty"`
|
|
Scaleuppolicies []string `json:"scaleuppolicies,omitempty"`
|
|
State string `json:"state,omitempty"`
|
|
Vmprofileid string `json:"vmprofileid,omitempty"`
|
|
}
|