//

// 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 cloudstack

import (

"encoding/json"

"fmt"

"net/url"

"strconv"

"strings"

)

type AutoScaleServiceIface interface {

CreateAutoScalePolicy(p *CreateAutoScalePolicyParams) (*CreateAutoScalePolicyResponse, error)

NewCreateAutoScalePolicyParams(action string, conditionids []string, duration int) *CreateAutoScalePolicyParams

CreateAutoScaleVmGroup(p *CreateAutoScaleVmGroupParams) (*CreateAutoScaleVmGroupResponse, error)

NewCreateAutoScaleVmGroupParams(lbruleid string, maxmembers int, minmembers int, scaledownpolicyids []string, scaleuppolicyids []string, vmprofileid string) *CreateAutoScaleVmGroupParams

CreateAutoScaleVmProfile(p *CreateAutoScaleVmProfileParams) (*CreateAutoScaleVmProfileResponse, error)

NewCreateAutoScaleVmProfileParams(serviceofferingid string, templateid string, zoneid string) *CreateAutoScaleVmProfileParams

CreateCondition(p *CreateConditionParams) (*CreateConditionResponse, error)

NewCreateConditionParams(counterid string, relationaloperator string, threshold int64) *CreateConditionParams

CreateCounter(p *CreateCounterParams) (*CreateCounterResponse, error)

NewCreateCounterParams(name string, provider string, source string, value string) *CreateCounterParams

DeleteAutoScalePolicy(p *DeleteAutoScalePolicyParams) (*DeleteAutoScalePolicyResponse, error)

NewDeleteAutoScalePolicyParams(id string) *DeleteAutoScalePolicyParams

DeleteAutoScaleVmGroup(p *DeleteAutoScaleVmGroupParams) (*DeleteAutoScaleVmGroupResponse, error)

NewDeleteAutoScaleVmGroupParams(id string) *DeleteAutoScaleVmGroupParams

DeleteAutoScaleVmProfile(p *DeleteAutoScaleVmProfileParams) (*DeleteAutoScaleVmProfileResponse, error)

NewDeleteAutoScaleVmProfileParams(id string) *DeleteAutoScaleVmProfileParams

DeleteCondition(p *DeleteConditionParams) (*DeleteConditionResponse, error)

NewDeleteConditionParams(id string) *DeleteConditionParams

DeleteCounter(p *DeleteCounterParams) (*DeleteCounterResponse, error)

NewDeleteCounterParams(id string) *DeleteCounterParams

DisableAutoScaleVmGroup(p *DisableAutoScaleVmGroupParams) (*DisableAutoScaleVmGroupResponse, error)

NewDisableAutoScaleVmGroupParams(id string) *DisableAutoScaleVmGroupParams

EnableAutoScaleVmGroup(p *EnableAutoScaleVmGroupParams) (*EnableAutoScaleVmGroupResponse, error)

NewEnableAutoScaleVmGroupParams(id string) *EnableAutoScaleVmGroupParams

ListAutoScalePolicies(p *ListAutoScalePoliciesParams) (*ListAutoScalePoliciesResponse, error)

NewListAutoScalePoliciesParams() *ListAutoScalePoliciesParams

GetAutoScalePolicyID(name string, opts ...OptionFunc) (string, int, error)

GetAutoScalePolicyByName(name string, opts ...OptionFunc) (*AutoScalePolicy, int, error)

GetAutoScalePolicyByID(id string, opts ...OptionFunc) (*AutoScalePolicy, int, error)

ListAutoScaleVmGroups(p *ListAutoScaleVmGroupsParams) (*ListAutoScaleVmGroupsResponse, error)

NewListAutoScaleVmGroupsParams() *ListAutoScaleVmGroupsParams

GetAutoScaleVmGroupID(name string, opts ...OptionFunc) (string, int, error)

GetAutoScaleVmGroupByName(name string, opts ...OptionFunc) (*AutoScaleVmGroup, int, error)

GetAutoScaleVmGroupByID(id string, opts ...OptionFunc) (*AutoScaleVmGroup, int, error)

ListAutoScaleVmProfiles(p *ListAutoScaleVmProfilesParams) (*ListAutoScaleVmProfilesResponse, error)

NewListAutoScaleVmProfilesParams() *ListAutoScaleVmProfilesParams

GetAutoScaleVmProfileByID(id string, opts ...OptionFunc) (*AutoScaleVmProfile, int, error)

ListConditions(p *ListConditionsParams) (*ListConditionsResponse, error)

NewListConditionsParams() *ListConditionsParams

GetConditionByID(id string, opts ...OptionFunc) (*Condition, int, error)

ListCounters(p *ListCountersParams) (*ListCountersResponse, error)

NewListCountersParams() *ListCountersParams

GetCounterID(name string, opts ...OptionFunc) (string, int, error)

GetCounterByName(name string, opts ...OptionFunc) (*Counter, int, error)

GetCounterByID(id string, opts ...OptionFunc) (*Counter, int, error)

UpdateAutoScalePolicy(p *UpdateAutoScalePolicyParams) (*UpdateAutoScalePolicyResponse, error)

NewUpdateAutoScalePolicyParams(id string) *UpdateAutoScalePolicyParams

UpdateAutoScaleVmGroup(p *UpdateAutoScaleVmGroupParams) (*UpdateAutoScaleVmGroupResponse, error)

NewUpdateAutoScaleVmGroupParams(id string) *UpdateAutoScaleVmGroupParams

UpdateAutoScaleVmProfile(p *UpdateAutoScaleVmProfileParams) (*UpdateAutoScaleVmProfileResponse, error)

NewUpdateAutoScaleVmProfileParams(id string) *UpdateAutoScaleVmProfileParams

UpdateCondition(p *UpdateConditionParams) (*UpdateConditionResponse, error)

NewUpdateConditionParams(id string, relationaloperator string, threshold int64) *UpdateConditionParams

}

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["name"]; found {

u.Set("name", v.(string))

}

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

}

func (p *CreateAutoScalePolicyParams) ResetAction() {

if p.p != nil && p.p["action"] != nil {

delete(p.p, "action")

}

}

func (p *CreateAutoScalePolicyParams) GetAction() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["action"].(string)

return value, ok

}

func (p *CreateAutoScalePolicyParams) SetConditionids(v []string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["conditionids"] = v

}

func (p *CreateAutoScalePolicyParams) ResetConditionids() {

if p.p != nil && p.p["conditionids"] != nil {

delete(p.p, "conditionids")

}

}

func (p *CreateAutoScalePolicyParams) GetConditionids() ([]string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["conditionids"].([]string)

return value, ok

}

func (p *CreateAutoScalePolicyParams) SetDuration(v int) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["duration"] = v

}

func (p *CreateAutoScalePolicyParams) ResetDuration() {

if p.p != nil && p.p["duration"] != nil {

delete(p.p, "duration")

}

}

func (p *CreateAutoScalePolicyParams) GetDuration() (int, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["duration"].(int)

return value, ok

}

func (p *CreateAutoScalePolicyParams) SetName(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["name"] = v

}

func (p *CreateAutoScalePolicyParams) ResetName() {

if p.p != nil && p.p["name"] != nil {

delete(p.p, "name")

}

}

func (p *CreateAutoScalePolicyParams) GetName() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["name"].(string)

return value, ok

}

func (p *CreateAutoScalePolicyParams) SetQuiettime(v int) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["quiettime"] = v

}

func (p *CreateAutoScalePolicyParams) ResetQuiettime() {

if p.p != nil && p.p["quiettime"] != nil {

delete(p.p, "quiettime")

}

}

func (p *CreateAutoScalePolicyParams) GetQuiettime() (int, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["quiettime"].(int)

return value, ok

}

// 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.newPostRequest("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 {

Account string `json:"account"`

Action string `json:"action"`

Conditions []*Condition `json:"conditions"`

Domain string `json:"domain"`

Domainid string `json:"domainid"`

Domainpath string `json:"domainpath"`

Duration int `json:"duration"`

Id string `json:"id"`

JobID string `json:"jobid"`

Jobstatus int `json:"jobstatus"`

Name string `json:"name"`

Project string `json:"project"`

Projectid string `json:"projectid"`

Quiettime int `json:"quiettime"`

}

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["name"]; found {

u.Set("name", v.(string))

}

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

}

func (p *CreateAutoScaleVmGroupParams) ResetFordisplay() {

if p.p != nil && p.p["fordisplay"] != nil {

delete(p.p, "fordisplay")

}

}

func (p *CreateAutoScaleVmGroupParams) GetFordisplay() (bool, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["fordisplay"].(bool)

return value, ok

}

func (p *CreateAutoScaleVmGroupParams) SetInterval(v int) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["interval"] = v

}

func (p *CreateAutoScaleVmGroupParams) ResetInterval() {

if p.p != nil && p.p["interval"] != nil {

delete(p.p, "interval")

}

}

func (p *CreateAutoScaleVmGroupParams) GetInterval() (int, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["interval"].(int)

return value, ok

}

func (p *CreateAutoScaleVmGroupParams) SetLbruleid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["lbruleid"] = v

}

func (p *CreateAutoScaleVmGroupParams) ResetLbruleid() {

if p.p != nil && p.p["lbruleid"] != nil {

delete(p.p, "lbruleid")

}

}

func (p *CreateAutoScaleVmGroupParams) GetLbruleid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["lbruleid"].(string)

return value, ok

}

func (p *CreateAutoScaleVmGroupParams) SetMaxmembers(v int) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["maxmembers"] = v

}

func (p *CreateAutoScaleVmGroupParams) ResetMaxmembers() {

if p.p != nil && p.p["maxmembers"] != nil {

delete(p.p, "maxmembers")

}

}

func (p *CreateAutoScaleVmGroupParams) GetMaxmembers() (int, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["maxmembers"].(int)

return value, ok

}

func (p *CreateAutoScaleVmGroupParams) SetMinmembers(v int) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["minmembers"] = v

}

func (p *CreateAutoScaleVmGroupParams) ResetMinmembers() {

if p.p != nil && p.p["minmembers"] != nil {

delete(p.p, "minmembers")

}

}

func (p *CreateAutoScaleVmGroupParams) GetMinmembers() (int, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["minmembers"].(int)

return value, ok

}

func (p *CreateAutoScaleVmGroupParams) SetName(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["name"] = v

}

func (p *CreateAutoScaleVmGroupParams) ResetName() {

if p.p != nil && p.p["name"] != nil {

delete(p.p, "name")

}

}

func (p *CreateAutoScaleVmGroupParams) GetName() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["name"].(string)

return value, ok

}

func (p *CreateAutoScaleVmGroupParams) SetScaledownpolicyids(v []string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["scaledownpolicyids"] = v

}

func (p *CreateAutoScaleVmGroupParams) ResetScaledownpolicyids() {

if p.p != nil && p.p["scaledownpolicyids"] != nil {

delete(p.p, "scaledownpolicyids")

}

}

func (p *CreateAutoScaleVmGroupParams) GetScaledownpolicyids() ([]string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["scaledownpolicyids"].([]string)

return value, ok

}

func (p *CreateAutoScaleVmGroupParams) SetScaleuppolicyids(v []string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["scaleuppolicyids"] = v

}

func (p *CreateAutoScaleVmGroupParams) ResetScaleuppolicyids() {

if p.p != nil && p.p["scaleuppolicyids"] != nil {

delete(p.p, "scaleuppolicyids")

}

}

func (p *CreateAutoScaleVmGroupParams) GetScaleuppolicyids() ([]string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["scaleuppolicyids"].([]string)

return value, ok

}

func (p *CreateAutoScaleVmGroupParams) SetVmprofileid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["vmprofileid"] = v

}

func (p *CreateAutoScaleVmGroupParams) ResetVmprofileid() {

if p.p != nil && p.p["vmprofileid"] != nil {

delete(p.p, "vmprofileid")

}

}

func (p *CreateAutoScaleVmGroupParams) GetVmprofileid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["vmprofileid"].(string)

return value, ok

}

// 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.newPostRequest("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 {

Account string `json:"account"`

Associatednetworkid string `json:"associatednetworkid"`

Associatednetworkname string `json:"associatednetworkname"`

Availablevirtualmachinecount int `json:"availablevirtualmachinecount"`

Created string `json:"created"`

Domain string `json:"domain"`

Domainid string `json:"domainid"`

Domainpath string `json:"domainpath"`

Fordisplay bool `json:"fordisplay"`

Hasannotations bool `json:"hasannotations"`

Id string `json:"id"`

Interval int `json:"interval"`

JobID string `json:"jobid"`

Jobstatus int `json:"jobstatus"`

Lbprovider string `json:"lbprovider"`

Lbruleid string `json:"lbruleid"`

Maxmembers int `json:"maxmembers"`

Minmembers int `json:"minmembers"`

Name string `json:"name"`

Privateport string `json:"privateport"`

Project string `json:"project"`

Projectid string `json:"projectid"`

Publicip string `json:"publicip"`

Publicipid string `json:"publicipid"`

Publicport string `json:"publicport"`

Scaledownpolicies []*AutoScalePolicy `json:"scaledownpolicies"`

Scaleuppolicies []*AutoScalePolicy `json:"scaleuppolicies"`

State string `json:"state"`

Vmprofileid string `json:"vmprofileid"`

}

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["account"]; found {

u.Set("account", v.(string))

}

if v, found := p.p["autoscaleuserid"]; found {

u.Set("autoscaleuserid", v.(string))

}

if v, found := p.p["counterparam"]; found {

m := v.(map[string]string)

for i, k := range getSortedKeysFromMap(m) {

u.Set(fmt.Sprintf("counterparam[%d].key", i), k)

u.Set(fmt.Sprintf("counterparam[%d].value", i), m[k])

}

}

if v, found := p.p["domainid"]; found {

u.Set("domainid", v.(string))

}

if v, found := p.p["expungevmgraceperiod"]; found {

vv := strconv.Itoa(v.(int))

u.Set("expungevmgraceperiod", vv)

}

if v, found := p.p["fordisplay"]; found {

vv := strconv.FormatBool(v.(bool))

u.Set("fordisplay", vv)

}

if v, found := p.p["otherdeployparams"]; found {

m := v.(map[string]string)

for i, k := range getSortedKeysFromMap(m) {

u.Set(fmt.Sprintf("otherdeployparams[%d].name", i), k)

u.Set(fmt.Sprintf("otherdeployparams[%d].value", i), m[k])

}

}

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["userdata"]; found {

u.Set("userdata", v.(string))

}

if v, found := p.p["userdatadetails"]; found {

m := v.(map[string]string)

for i, k := range getSortedKeysFromMap(m) {

u.Set(fmt.Sprintf("userdatadetails[%d].%s", i, k), m[k])

}

}

if v, found := p.p["userdataid"]; found {

u.Set("userdataid", v.(string))

}

if v, found := p.p["zoneid"]; found {

u.Set("zoneid", v.(string))

}

return u

}

func (p *CreateAutoScaleVmProfileParams) SetAccount(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["account"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetAccount() {

if p.p != nil && p.p["account"] != nil {

delete(p.p, "account")

}

}

func (p *CreateAutoScaleVmProfileParams) GetAccount() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["account"].(string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetAutoscaleuserid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["autoscaleuserid"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetAutoscaleuserid() {

if p.p != nil && p.p["autoscaleuserid"] != nil {

delete(p.p, "autoscaleuserid")

}

}

func (p *CreateAutoScaleVmProfileParams) GetAutoscaleuserid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["autoscaleuserid"].(string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetCounterparam(v map[string]string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["counterparam"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetCounterparam() {

if p.p != nil && p.p["counterparam"] != nil {

delete(p.p, "counterparam")

}

}

func (p *CreateAutoScaleVmProfileParams) GetCounterparam() (map[string]string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["counterparam"].(map[string]string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetDomainid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["domainid"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetDomainid() {

if p.p != nil && p.p["domainid"] != nil {

delete(p.p, "domainid")

}

}

func (p *CreateAutoScaleVmProfileParams) GetDomainid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["domainid"].(string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetExpungevmgraceperiod(v int) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["expungevmgraceperiod"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetExpungevmgraceperiod() {

if p.p != nil && p.p["expungevmgraceperiod"] != nil {

delete(p.p, "expungevmgraceperiod")

}

}

func (p *CreateAutoScaleVmProfileParams) GetExpungevmgraceperiod() (int, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["expungevmgraceperiod"].(int)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetFordisplay(v bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["fordisplay"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetFordisplay() {

if p.p != nil && p.p["fordisplay"] != nil {

delete(p.p, "fordisplay")

}

}

func (p *CreateAutoScaleVmProfileParams) GetFordisplay() (bool, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["fordisplay"].(bool)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetOtherdeployparams(v map[string]string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["otherdeployparams"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetOtherdeployparams() {

if p.p != nil && p.p["otherdeployparams"] != nil {

delete(p.p, "otherdeployparams")

}

}

func (p *CreateAutoScaleVmProfileParams) GetOtherdeployparams() (map[string]string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["otherdeployparams"].(map[string]string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetProjectid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["projectid"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetProjectid() {

if p.p != nil && p.p["projectid"] != nil {

delete(p.p, "projectid")

}

}

func (p *CreateAutoScaleVmProfileParams) GetProjectid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["projectid"].(string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetServiceofferingid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["serviceofferingid"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetServiceofferingid() {

if p.p != nil && p.p["serviceofferingid"] != nil {

delete(p.p, "serviceofferingid")

}

}

func (p *CreateAutoScaleVmProfileParams) GetServiceofferingid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["serviceofferingid"].(string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetTemplateid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["templateid"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetTemplateid() {

if p.p != nil && p.p["templateid"] != nil {

delete(p.p, "templateid")

}

}

func (p *CreateAutoScaleVmProfileParams) GetTemplateid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["templateid"].(string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetUserdata(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["userdata"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetUserdata() {

if p.p != nil && p.p["userdata"] != nil {

delete(p.p, "userdata")

}

}

func (p *CreateAutoScaleVmProfileParams) GetUserdata() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["userdata"].(string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetUserdatadetails(v map[string]string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["userdatadetails"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetUserdatadetails() {

if p.p != nil && p.p["userdatadetails"] != nil {

delete(p.p, "userdatadetails")

}

}

func (p *CreateAutoScaleVmProfileParams) GetUserdatadetails() (map[string]string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["userdatadetails"].(map[string]string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetUserdataid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["userdataid"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetUserdataid() {

if p.p != nil && p.p["userdataid"] != nil {

delete(p.p, "userdataid")

}

}

func (p *CreateAutoScaleVmProfileParams) GetUserdataid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["userdataid"].(string)

return value, ok

}

func (p *CreateAutoScaleVmProfileParams) SetZoneid(v string) {

if p.p == nil {

p.p = make(map[string]interface{})

}

p.p["zoneid"] = v

}

func (p *CreateAutoScaleVmProfileParams) ResetZoneid() {

if p.p != nil && p.p["zoneid"] != nil {

delete(p.p, "zoneid")

}

}

func (p *CreateAutoScaleVmProfileParams) GetZoneid() (string, bool) {

if p.p == nil {

p.p = make(map[string]interface{})

}

value, ok := p.p["zoneid"].(string)

return value, ok

}

// 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.newPostRequest("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

}