id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
145,800 |
xanzy/go-cloudstack
|
cloudstack/LoadBalancerService.go
|
UpdateLBStickinessPolicy
|
func (s *LoadBalancerService) UpdateLBStickinessPolicy(p *UpdateLBStickinessPolicyParams) (*UpdateLBStickinessPolicyResponse, error) {
resp, err := s.cs.newRequest("updateLBStickinessPolicy", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateLBStickinessPolicyResponse
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
}
|
go
|
func (s *LoadBalancerService) UpdateLBStickinessPolicy(p *UpdateLBStickinessPolicyParams) (*UpdateLBStickinessPolicyResponse, error) {
resp, err := s.cs.newRequest("updateLBStickinessPolicy", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateLBStickinessPolicyResponse
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
}
|
[
"func",
"(",
"s",
"*",
"LoadBalancerService",
")",
"UpdateLBStickinessPolicy",
"(",
"p",
"*",
"UpdateLBStickinessPolicyParams",
")",
"(",
"*",
"UpdateLBStickinessPolicyResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"UpdateLBStickinessPolicyResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Updates load balancer stickiness policy
|
[
"Updates",
"load",
"balancer",
"stickiness",
"policy"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/LoadBalancerService.go#L4283-L4315
|
145,801 |
xanzy/go-cloudstack
|
cloudstack/LoadBalancerService.go
|
NewUpdateLoadBalancerParams
|
func (s *LoadBalancerService) NewUpdateLoadBalancerParams(id string) *UpdateLoadBalancerParams {
p := &UpdateLoadBalancerParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *LoadBalancerService) NewUpdateLoadBalancerParams(id string) *UpdateLoadBalancerParams {
p := &UpdateLoadBalancerParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"LoadBalancerService",
")",
"NewUpdateLoadBalancerParams",
"(",
"id",
"string",
")",
"*",
"UpdateLoadBalancerParams",
"{",
"p",
":=",
"&",
"UpdateLoadBalancerParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateLoadBalancerParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateLoadBalancerParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/LoadBalancerService.go#L4388-L4393
|
145,802 |
xanzy/go-cloudstack
|
cloudstack/LoadBalancerService.go
|
UpdateLoadBalancer
|
func (s *LoadBalancerService) UpdateLoadBalancer(p *UpdateLoadBalancerParams) (*UpdateLoadBalancerResponse, error) {
resp, err := s.cs.newRequest("updateLoadBalancer", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateLoadBalancerResponse
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
}
|
go
|
func (s *LoadBalancerService) UpdateLoadBalancer(p *UpdateLoadBalancerParams) (*UpdateLoadBalancerResponse, error) {
resp, err := s.cs.newRequest("updateLoadBalancer", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateLoadBalancerResponse
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
}
|
[
"func",
"(",
"s",
"*",
"LoadBalancerService",
")",
"UpdateLoadBalancer",
"(",
"p",
"*",
"UpdateLoadBalancerParams",
")",
"(",
"*",
"UpdateLoadBalancerResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"UpdateLoadBalancerResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Updates a load balancer
|
[
"Updates",
"a",
"load",
"balancer"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/LoadBalancerService.go#L4396-L4428
|
145,803 |
xanzy/go-cloudstack
|
cloudstack/LoadBalancerService.go
|
NewUpdateLoadBalancerRuleParams
|
func (s *LoadBalancerService) NewUpdateLoadBalancerRuleParams(id string) *UpdateLoadBalancerRuleParams {
p := &UpdateLoadBalancerRuleParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *LoadBalancerService) NewUpdateLoadBalancerRuleParams(id string) *UpdateLoadBalancerRuleParams {
p := &UpdateLoadBalancerRuleParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"LoadBalancerService",
")",
"NewUpdateLoadBalancerRuleParams",
"(",
"id",
"string",
")",
"*",
"UpdateLoadBalancerRuleParams",
"{",
"p",
":=",
"&",
"UpdateLoadBalancerRuleParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateLoadBalancerRuleParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateLoadBalancerRuleParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/LoadBalancerService.go#L4555-L4560
|
145,804 |
xanzy/go-cloudstack
|
cloudstack/LoadBalancerService.go
|
NewUploadSslCertParams
|
func (s *LoadBalancerService) NewUploadSslCertParams(certificate string, name string, privatekey string) *UploadSslCertParams {
p := &UploadSslCertParams{}
p.p = make(map[string]interface{})
p.p["certificate"] = certificate
p.p["name"] = name
p.p["privatekey"] = privatekey
return p
}
|
go
|
func (s *LoadBalancerService) NewUploadSslCertParams(certificate string, name string, privatekey string) *UploadSslCertParams {
p := &UploadSslCertParams{}
p.p = make(map[string]interface{})
p.p["certificate"] = certificate
p.p["name"] = name
p.p["privatekey"] = privatekey
return p
}
|
[
"func",
"(",
"s",
"*",
"LoadBalancerService",
")",
"NewUploadSslCertParams",
"(",
"certificate",
"string",
",",
"name",
"string",
",",
"privatekey",
"string",
")",
"*",
"UploadSslCertParams",
"{",
"p",
":=",
"&",
"UploadSslCertParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"certificate",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"privatekey",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UploadSslCertParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UploadSslCertParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/LoadBalancerService.go#L4724-L4731
|
145,805 |
xanzy/go-cloudstack
|
cloudstack/LoadBalancerService.go
|
UploadSslCert
|
func (s *LoadBalancerService) UploadSslCert(p *UploadSslCertParams) (*UploadSslCertResponse, error) {
resp, err := s.cs.newRequest("uploadSslCert", p.toURLValues())
if err != nil {
return nil, err
}
var r UploadSslCertResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *LoadBalancerService) UploadSslCert(p *UploadSslCertParams) (*UploadSslCertResponse, error) {
resp, err := s.cs.newRequest("uploadSslCert", p.toURLValues())
if err != nil {
return nil, err
}
var r UploadSslCertResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"LoadBalancerService",
")",
"UploadSslCert",
"(",
"p",
"*",
"UploadSslCertParams",
")",
"(",
"*",
"UploadSslCertResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"UploadSslCertResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Upload a certificate to CloudStack
|
[
"Upload",
"a",
"certificate",
"to",
"CloudStack"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/LoadBalancerService.go#L4734-L4746
|
145,806 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
NewAddUcsManagerParams
|
func (s *UCSService) NewAddUcsManagerParams(password string, url string, username string, zoneid string) *AddUcsManagerParams {
p := &AddUcsManagerParams{}
p.p = make(map[string]interface{})
p.p["password"] = password
p.p["url"] = url
p.p["username"] = username
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *UCSService) NewAddUcsManagerParams(password string, url string, username string, zoneid string) *AddUcsManagerParams {
p := &AddUcsManagerParams{}
p.p = make(map[string]interface{})
p.p["password"] = password
p.p["url"] = url
p.p["username"] = username
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"NewAddUcsManagerParams",
"(",
"password",
"string",
",",
"url",
"string",
",",
"username",
"string",
",",
"zoneid",
"string",
")",
"*",
"AddUcsManagerParams",
"{",
"p",
":=",
"&",
"AddUcsManagerParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"password",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"url",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"username",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddUcsManagerParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddUcsManagerParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L96-L104
|
145,807 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
AddUcsManager
|
func (s *UCSService) AddUcsManager(p *AddUcsManagerParams) (*AddUcsManagerResponse, error) {
resp, err := s.cs.newRequest("addUcsManager", p.toURLValues())
if err != nil {
return nil, err
}
var r AddUcsManagerResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *UCSService) AddUcsManager(p *AddUcsManagerParams) (*AddUcsManagerResponse, error) {
resp, err := s.cs.newRequest("addUcsManager", p.toURLValues())
if err != nil {
return nil, err
}
var r AddUcsManagerResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"AddUcsManager",
"(",
"p",
"*",
"AddUcsManagerParams",
")",
"(",
"*",
"AddUcsManagerResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddUcsManagerResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Adds a Ucs manager
|
[
"Adds",
"a",
"Ucs",
"manager"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L107-L119
|
145,808 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
NewAssociateUcsProfileToBladeParams
|
func (s *UCSService) NewAssociateUcsProfileToBladeParams(bladeid string, profiledn string, ucsmanagerid string) *AssociateUcsProfileToBladeParams {
p := &AssociateUcsProfileToBladeParams{}
p.p = make(map[string]interface{})
p.p["bladeid"] = bladeid
p.p["profiledn"] = profiledn
p.p["ucsmanagerid"] = ucsmanagerid
return p
}
|
go
|
func (s *UCSService) NewAssociateUcsProfileToBladeParams(bladeid string, profiledn string, ucsmanagerid string) *AssociateUcsProfileToBladeParams {
p := &AssociateUcsProfileToBladeParams{}
p.p = make(map[string]interface{})
p.p["bladeid"] = bladeid
p.p["profiledn"] = profiledn
p.p["ucsmanagerid"] = ucsmanagerid
return p
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"NewAssociateUcsProfileToBladeParams",
"(",
"bladeid",
"string",
",",
"profiledn",
"string",
",",
"ucsmanagerid",
"string",
")",
"*",
"AssociateUcsProfileToBladeParams",
"{",
"p",
":=",
"&",
"AssociateUcsProfileToBladeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"bladeid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"profiledn",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"ucsmanagerid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AssociateUcsProfileToBladeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AssociateUcsProfileToBladeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L175-L182
|
145,809 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
AssociateUcsProfileToBlade
|
func (s *UCSService) AssociateUcsProfileToBlade(p *AssociateUcsProfileToBladeParams) (*AssociateUcsProfileToBladeResponse, error) {
resp, err := s.cs.newRequest("associateUcsProfileToBlade", p.toURLValues())
if err != nil {
return nil, err
}
var r AssociateUcsProfileToBladeResponse
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
}
|
go
|
func (s *UCSService) AssociateUcsProfileToBlade(p *AssociateUcsProfileToBladeParams) (*AssociateUcsProfileToBladeResponse, error) {
resp, err := s.cs.newRequest("associateUcsProfileToBlade", p.toURLValues())
if err != nil {
return nil, err
}
var r AssociateUcsProfileToBladeResponse
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
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"AssociateUcsProfileToBlade",
"(",
"p",
"*",
"AssociateUcsProfileToBladeParams",
")",
"(",
"*",
"AssociateUcsProfileToBladeResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AssociateUcsProfileToBladeResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// associate a profile to a blade
|
[
"associate",
"a",
"profile",
"to",
"a",
"blade"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L185-L217
|
145,810 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
NewDeleteUcsManagerParams
|
func (s *UCSService) NewDeleteUcsManagerParams(ucsmanagerid string) *DeleteUcsManagerParams {
p := &DeleteUcsManagerParams{}
p.p = make(map[string]interface{})
p.p["ucsmanagerid"] = ucsmanagerid
return p
}
|
go
|
func (s *UCSService) NewDeleteUcsManagerParams(ucsmanagerid string) *DeleteUcsManagerParams {
p := &DeleteUcsManagerParams{}
p.p = make(map[string]interface{})
p.p["ucsmanagerid"] = ucsmanagerid
return p
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"NewDeleteUcsManagerParams",
"(",
"ucsmanagerid",
"string",
")",
"*",
"DeleteUcsManagerParams",
"{",
"p",
":=",
"&",
"DeleteUcsManagerParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"ucsmanagerid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DeleteUcsManagerParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteUcsManagerParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L253-L258
|
145,811 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
DeleteUcsManager
|
func (s *UCSService) DeleteUcsManager(p *DeleteUcsManagerParams) (*DeleteUcsManagerResponse, error) {
resp, err := s.cs.newRequest("deleteUcsManager", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteUcsManagerResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *UCSService) DeleteUcsManager(p *DeleteUcsManagerParams) (*DeleteUcsManagerResponse, error) {
resp, err := s.cs.newRequest("deleteUcsManager", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteUcsManagerResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"DeleteUcsManager",
"(",
"p",
"*",
"DeleteUcsManagerParams",
")",
"(",
"*",
"DeleteUcsManagerResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeleteUcsManagerResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Delete a Ucs manager
|
[
"Delete",
"a",
"Ucs",
"manager"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L261-L273
|
145,812 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
NewListUcsBladesParams
|
func (s *UCSService) NewListUcsBladesParams(ucsmanagerid string) *ListUcsBladesParams {
p := &ListUcsBladesParams{}
p.p = make(map[string]interface{})
p.p["ucsmanagerid"] = ucsmanagerid
return p
}
|
go
|
func (s *UCSService) NewListUcsBladesParams(ucsmanagerid string) *ListUcsBladesParams {
p := &ListUcsBladesParams{}
p.p = make(map[string]interface{})
p.p["ucsmanagerid"] = ucsmanagerid
return p
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"NewListUcsBladesParams",
"(",
"ucsmanagerid",
"string",
")",
"*",
"ListUcsBladesParams",
"{",
"p",
":=",
"&",
"ListUcsBladesParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"ucsmanagerid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListUcsBladesParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListUcsBladesParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L359-L364
|
145,813 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
ListUcsBlades
|
func (s *UCSService) ListUcsBlades(p *ListUcsBladesParams) (*ListUcsBladesResponse, error) {
resp, err := s.cs.newRequest("listUcsBlades", p.toURLValues())
if err != nil {
return nil, err
}
var r ListUcsBladesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *UCSService) ListUcsBlades(p *ListUcsBladesParams) (*ListUcsBladesResponse, error) {
resp, err := s.cs.newRequest("listUcsBlades", p.toURLValues())
if err != nil {
return nil, err
}
var r ListUcsBladesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"ListUcsBlades",
"(",
"p",
"*",
"ListUcsBladesParams",
")",
"(",
"*",
"ListUcsBladesResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListUcsBladesResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// List ucs blades
|
[
"List",
"ucs",
"blades"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L367-L379
|
145,814 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
NewListUcsManagersParams
|
func (s *UCSService) NewListUcsManagersParams() *ListUcsManagersParams {
p := &ListUcsManagersParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *UCSService) NewListUcsManagersParams() *ListUcsManagersParams {
p := &ListUcsManagersParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"NewListUcsManagersParams",
"(",
")",
"*",
"ListUcsManagersParams",
"{",
"p",
":=",
"&",
"ListUcsManagersParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListUcsManagersParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListUcsManagersParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L465-L469
|
145,815 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
ListUcsManagers
|
func (s *UCSService) ListUcsManagers(p *ListUcsManagersParams) (*ListUcsManagersResponse, error) {
resp, err := s.cs.newRequest("listUcsManagers", p.toURLValues())
if err != nil {
return nil, err
}
var r ListUcsManagersResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *UCSService) ListUcsManagers(p *ListUcsManagersParams) (*ListUcsManagersResponse, error) {
resp, err := s.cs.newRequest("listUcsManagers", p.toURLValues())
if err != nil {
return nil, err
}
var r ListUcsManagersResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"ListUcsManagers",
"(",
"p",
"*",
"ListUcsManagersParams",
")",
"(",
"*",
"ListUcsManagersResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListUcsManagersResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// List ucs manager
|
[
"List",
"ucs",
"manager"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L555-L567
|
145,816 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
NewListUcsProfilesParams
|
func (s *UCSService) NewListUcsProfilesParams(ucsmanagerid string) *ListUcsProfilesParams {
p := &ListUcsProfilesParams{}
p.p = make(map[string]interface{})
p.p["ucsmanagerid"] = ucsmanagerid
return p
}
|
go
|
func (s *UCSService) NewListUcsProfilesParams(ucsmanagerid string) *ListUcsProfilesParams {
p := &ListUcsProfilesParams{}
p.p = make(map[string]interface{})
p.p["ucsmanagerid"] = ucsmanagerid
return p
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"NewListUcsProfilesParams",
"(",
"ucsmanagerid",
"string",
")",
"*",
"ListUcsProfilesParams",
"{",
"p",
":=",
"&",
"ListUcsProfilesParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"ucsmanagerid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListUcsProfilesParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListUcsProfilesParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L641-L646
|
145,817 |
xanzy/go-cloudstack
|
cloudstack/UCSService.go
|
ListUcsProfiles
|
func (s *UCSService) ListUcsProfiles(p *ListUcsProfilesParams) (*ListUcsProfilesResponse, error) {
resp, err := s.cs.newRequest("listUcsProfiles", p.toURLValues())
if err != nil {
return nil, err
}
var r ListUcsProfilesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *UCSService) ListUcsProfiles(p *ListUcsProfilesParams) (*ListUcsProfilesResponse, error) {
resp, err := s.cs.newRequest("listUcsProfiles", p.toURLValues())
if err != nil {
return nil, err
}
var r ListUcsProfilesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"UCSService",
")",
"ListUcsProfiles",
"(",
"p",
"*",
"ListUcsProfilesParams",
")",
"(",
"*",
"ListUcsProfilesResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListUcsProfilesResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// List profile in ucs manager
|
[
"List",
"profile",
"in",
"ucs",
"manager"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/UCSService.go#L649-L661
|
145,818 |
xanzy/go-cloudstack
|
cloudstack/RegionService.go
|
NewAddRegionParams
|
func (s *RegionService) NewAddRegionParams(endpoint string, id int, name string) *AddRegionParams {
p := &AddRegionParams{}
p.p = make(map[string]interface{})
p.p["endpoint"] = endpoint
p.p["id"] = id
p.p["name"] = name
return p
}
|
go
|
func (s *RegionService) NewAddRegionParams(endpoint string, id int, name string) *AddRegionParams {
p := &AddRegionParams{}
p.p = make(map[string]interface{})
p.p["endpoint"] = endpoint
p.p["id"] = id
p.p["name"] = name
return p
}
|
[
"func",
"(",
"s",
"*",
"RegionService",
")",
"NewAddRegionParams",
"(",
"endpoint",
"string",
",",
"id",
"int",
",",
"name",
"string",
")",
"*",
"AddRegionParams",
"{",
"p",
":=",
"&",
"AddRegionParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"endpoint",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddRegionParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddRegionParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/RegionService.go#L73-L80
|
145,819 |
xanzy/go-cloudstack
|
cloudstack/RegionService.go
|
AddRegion
|
func (s *RegionService) AddRegion(p *AddRegionParams) (*AddRegionResponse, error) {
resp, err := s.cs.newRequest("addRegion", p.toURLValues())
if err != nil {
return nil, err
}
var r AddRegionResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *RegionService) AddRegion(p *AddRegionParams) (*AddRegionResponse, error) {
resp, err := s.cs.newRequest("addRegion", p.toURLValues())
if err != nil {
return nil, err
}
var r AddRegionResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"RegionService",
")",
"AddRegion",
"(",
"p",
"*",
"AddRegionParams",
")",
"(",
"*",
"AddRegionResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddRegionResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Adds a Region
|
[
"Adds",
"a",
"Region"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/RegionService.go#L83-L95
|
145,820 |
xanzy/go-cloudstack
|
cloudstack/RegionService.go
|
NewListRegionsParams
|
func (s *RegionService) NewListRegionsParams() *ListRegionsParams {
p := &ListRegionsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *RegionService) NewListRegionsParams() *ListRegionsParams {
p := &ListRegionsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"RegionService",
")",
"NewListRegionsParams",
"(",
")",
"*",
"ListRegionsParams",
"{",
"p",
":=",
"&",
"ListRegionsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListRegionsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListRegionsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/RegionService.go#L177-L181
|
145,821 |
xanzy/go-cloudstack
|
cloudstack/RegionService.go
|
NewRemoveRegionParams
|
func (s *RegionService) NewRemoveRegionParams(id int) *RemoveRegionParams {
p := &RemoveRegionParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *RegionService) NewRemoveRegionParams(id int) *RemoveRegionParams {
p := &RemoveRegionParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"RegionService",
")",
"NewRemoveRegionParams",
"(",
"id",
"int",
")",
"*",
"RemoveRegionParams",
"{",
"p",
":=",
"&",
"RemoveRegionParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new RemoveRegionParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"RemoveRegionParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/RegionService.go#L237-L242
|
145,822 |
xanzy/go-cloudstack
|
cloudstack/RegionService.go
|
RemoveRegion
|
func (s *RegionService) RemoveRegion(p *RemoveRegionParams) (*RemoveRegionResponse, error) {
resp, err := s.cs.newRequest("removeRegion", p.toURLValues())
if err != nil {
return nil, err
}
var r RemoveRegionResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *RegionService) RemoveRegion(p *RemoveRegionParams) (*RemoveRegionResponse, error) {
resp, err := s.cs.newRequest("removeRegion", p.toURLValues())
if err != nil {
return nil, err
}
var r RemoveRegionResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"RegionService",
")",
"RemoveRegion",
"(",
"p",
"*",
"RemoveRegionParams",
")",
"(",
"*",
"RemoveRegionResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"RemoveRegionResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Removes specified region
|
[
"Removes",
"specified",
"region"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/RegionService.go#L245-L257
|
145,823 |
xanzy/go-cloudstack
|
cloudstack/RegionService.go
|
NewUpdateRegionParams
|
func (s *RegionService) NewUpdateRegionParams(id int) *UpdateRegionParams {
p := &UpdateRegionParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *RegionService) NewUpdateRegionParams(id int) *UpdateRegionParams {
p := &UpdateRegionParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"RegionService",
")",
"NewUpdateRegionParams",
"(",
"id",
"int",
")",
"*",
"UpdateRegionParams",
"{",
"p",
":=",
"&",
"UpdateRegionParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateRegionParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateRegionParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/RegionService.go#L331-L336
|
145,824 |
xanzy/go-cloudstack
|
cloudstack/RegionService.go
|
UpdateRegion
|
func (s *RegionService) UpdateRegion(p *UpdateRegionParams) (*UpdateRegionResponse, error) {
resp, err := s.cs.newRequest("updateRegion", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateRegionResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *RegionService) UpdateRegion(p *UpdateRegionParams) (*UpdateRegionResponse, error) {
resp, err := s.cs.newRequest("updateRegion", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateRegionResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"RegionService",
")",
"UpdateRegion",
"(",
"p",
"*",
"UpdateRegionParams",
")",
"(",
"*",
"UpdateRegionResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"UpdateRegionResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Updates a region
|
[
"Updates",
"a",
"region"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/RegionService.go#L339-L351
|
145,825 |
xanzy/go-cloudstack
|
cloudstack/SystemCapacityService.go
|
NewListCapacityParams
|
func (s *SystemCapacityService) NewListCapacityParams() *ListCapacityParams {
p := &ListCapacityParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *SystemCapacityService) NewListCapacityParams() *ListCapacityParams {
p := &ListCapacityParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemCapacityService",
")",
"NewListCapacityParams",
"(",
")",
"*",
"ListCapacityParams",
"{",
"p",
":=",
"&",
"ListCapacityParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListCapacityParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListCapacityParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemCapacityService.go#L142-L146
|
145,826 |
xanzy/go-cloudstack
|
cloudstack/SystemCapacityService.go
|
ListCapacity
|
func (s *SystemCapacityService) ListCapacity(p *ListCapacityParams) (*ListCapacityResponse, error) {
resp, err := s.cs.newRequest("listCapacity", p.toURLValues())
if err != nil {
return nil, err
}
var r ListCapacityResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *SystemCapacityService) ListCapacity(p *ListCapacityParams) (*ListCapacityResponse, error) {
resp, err := s.cs.newRequest("listCapacity", p.toURLValues())
if err != nil {
return nil, err
}
var r ListCapacityResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"SystemCapacityService",
")",
"ListCapacity",
"(",
"p",
"*",
"ListCapacityParams",
")",
"(",
"*",
"ListCapacityResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListCapacityResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Lists all the system wide capacities.
|
[
"Lists",
"all",
"the",
"system",
"wide",
"capacities",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemCapacityService.go#L149-L161
|
145,827 |
xanzy/go-cloudstack
|
cloudstack/cloudstack.go
|
NewAsyncClient
|
func NewAsyncClient(apiurl string, apikey string, secret string, verifyssl bool) *CloudStackClient {
cs := newClient(apiurl, apikey, secret, true, verifyssl)
return cs
}
|
go
|
func NewAsyncClient(apiurl string, apikey string, secret string, verifyssl bool) *CloudStackClient {
cs := newClient(apiurl, apikey, secret, true, verifyssl)
return cs
}
|
[
"func",
"NewAsyncClient",
"(",
"apiurl",
"string",
",",
"apikey",
"string",
",",
"secret",
"string",
",",
"verifyssl",
"bool",
")",
"*",
"CloudStackClient",
"{",
"cs",
":=",
"newClient",
"(",
"apiurl",
",",
"apikey",
",",
"secret",
",",
"true",
",",
"verifyssl",
")",
"\n",
"return",
"cs",
"\n",
"}"
] |
// For sync API calls this client behaves exactly the same as a standard client call, but for async API calls
// this client will wait until the async job is finished or until the configured AsyncTimeout is reached. When the async
// job finishes successfully it will return actual object received from the API and nil, but when the timout is
// reached it will return the initial object containing the async job ID for the running job and a warning.
|
[
"For",
"sync",
"API",
"calls",
"this",
"client",
"behaves",
"exactly",
"the",
"same",
"as",
"a",
"standard",
"client",
"call",
"but",
"for",
"async",
"API",
"calls",
"this",
"client",
"will",
"wait",
"until",
"the",
"async",
"job",
"is",
"finished",
"or",
"until",
"the",
"configured",
"AsyncTimeout",
"is",
"reached",
".",
"When",
"the",
"async",
"job",
"finishes",
"successfully",
"it",
"will",
"return",
"actual",
"object",
"received",
"from",
"the",
"API",
"and",
"nil",
"but",
"when",
"the",
"timout",
"is",
"reached",
"it",
"will",
"return",
"the",
"initial",
"object",
"containing",
"the",
"async",
"job",
"ID",
"for",
"the",
"running",
"job",
"and",
"a",
"warning",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/cloudstack.go#L256-L259
|
145,828 |
xanzy/go-cloudstack
|
cloudstack/cloudstack.go
|
DefaultOptions
|
func (cs *CloudStackClient) DefaultOptions(options ...OptionFunc) {
if options != nil {
cs.options = options
} else {
cs.options = []OptionFunc{}
}
}
|
go
|
func (cs *CloudStackClient) DefaultOptions(options ...OptionFunc) {
if options != nil {
cs.options = options
} else {
cs.options = []OptionFunc{}
}
}
|
[
"func",
"(",
"cs",
"*",
"CloudStackClient",
")",
"DefaultOptions",
"(",
"options",
"...",
"OptionFunc",
")",
"{",
"if",
"options",
"!=",
"nil",
"{",
"cs",
".",
"options",
"=",
"options",
"\n",
"}",
"else",
"{",
"cs",
".",
"options",
"=",
"[",
"]",
"OptionFunc",
"{",
"}",
"\n",
"}",
"\n",
"}"
] |
// Set any default options that would be added to all API calls that support it.
|
[
"Set",
"any",
"default",
"options",
"that",
"would",
"be",
"added",
"to",
"all",
"API",
"calls",
"that",
"support",
"it",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/cloudstack.go#L268-L274
|
145,829 |
xanzy/go-cloudstack
|
cloudstack/cloudstack.go
|
GetAsyncJobResult
|
func (cs *CloudStackClient) GetAsyncJobResult(jobid string, timeout int64) (json.RawMessage, error) {
var timer time.Duration
currentTime := time.Now().Unix()
for {
p := cs.Asyncjob.NewQueryAsyncJobResultParams(jobid)
r, err := cs.Asyncjob.QueryAsyncJobResult(p)
if err != nil {
return nil, err
}
// Status 1 means the job is finished successfully
if r.Jobstatus == 1 {
return r.Jobresult, nil
}
// When the status is 2, the job has failed
if r.Jobstatus == 2 {
if r.Jobresulttype == "text" {
return nil, fmt.Errorf(string(r.Jobresult))
} else {
return nil, fmt.Errorf("Undefined error: %s", string(r.Jobresult))
}
}
if time.Now().Unix()-currentTime > timeout {
return nil, AsyncTimeoutErr
}
// Add an (extremely simple) exponential backoff like feature to prevent
// flooding the CloudStack API
if timer < 15 {
timer++
}
time.Sleep(timer * time.Second)
}
}
|
go
|
func (cs *CloudStackClient) GetAsyncJobResult(jobid string, timeout int64) (json.RawMessage, error) {
var timer time.Duration
currentTime := time.Now().Unix()
for {
p := cs.Asyncjob.NewQueryAsyncJobResultParams(jobid)
r, err := cs.Asyncjob.QueryAsyncJobResult(p)
if err != nil {
return nil, err
}
// Status 1 means the job is finished successfully
if r.Jobstatus == 1 {
return r.Jobresult, nil
}
// When the status is 2, the job has failed
if r.Jobstatus == 2 {
if r.Jobresulttype == "text" {
return nil, fmt.Errorf(string(r.Jobresult))
} else {
return nil, fmt.Errorf("Undefined error: %s", string(r.Jobresult))
}
}
if time.Now().Unix()-currentTime > timeout {
return nil, AsyncTimeoutErr
}
// Add an (extremely simple) exponential backoff like feature to prevent
// flooding the CloudStack API
if timer < 15 {
timer++
}
time.Sleep(timer * time.Second)
}
}
|
[
"func",
"(",
"cs",
"*",
"CloudStackClient",
")",
"GetAsyncJobResult",
"(",
"jobid",
"string",
",",
"timeout",
"int64",
")",
"(",
"json",
".",
"RawMessage",
",",
"error",
")",
"{",
"var",
"timer",
"time",
".",
"Duration",
"\n",
"currentTime",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"\n\n",
"for",
"{",
"p",
":=",
"cs",
".",
"Asyncjob",
".",
"NewQueryAsyncJobResultParams",
"(",
"jobid",
")",
"\n",
"r",
",",
"err",
":=",
"cs",
".",
"Asyncjob",
".",
"QueryAsyncJobResult",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Status 1 means the job is finished successfully",
"if",
"r",
".",
"Jobstatus",
"==",
"1",
"{",
"return",
"r",
".",
"Jobresult",
",",
"nil",
"\n",
"}",
"\n\n",
"// When the status is 2, the job has failed",
"if",
"r",
".",
"Jobstatus",
"==",
"2",
"{",
"if",
"r",
".",
"Jobresulttype",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"string",
"(",
"r",
".",
"Jobresult",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"r",
".",
"Jobresult",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"-",
"currentTime",
">",
"timeout",
"{",
"return",
"nil",
",",
"AsyncTimeoutErr",
"\n",
"}",
"\n\n",
"// Add an (extremely simple) exponential backoff like feature to prevent",
"// flooding the CloudStack API",
"if",
"timer",
"<",
"15",
"{",
"timer",
"++",
"\n",
"}",
"\n\n",
"time",
".",
"Sleep",
"(",
"timer",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"}"
] |
// A helper function that you can use to get the result of a running async job. If the job is not finished within the configured
// timeout, the async job returns a AsyncTimeoutErr.
|
[
"A",
"helper",
"function",
"that",
"you",
"can",
"use",
"to",
"get",
"the",
"result",
"of",
"a",
"running",
"async",
"job",
".",
"If",
"the",
"job",
"is",
"not",
"finished",
"within",
"the",
"configured",
"timeout",
"the",
"async",
"job",
"returns",
"a",
"AsyncTimeoutErr",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/cloudstack.go#L280-L317
|
145,830 |
xanzy/go-cloudstack
|
cloudstack/cloudstack.go
|
getRawValue
|
func getRawValue(b json.RawMessage) (json.RawMessage, error) {
var m map[string]json.RawMessage
if err := json.Unmarshal(b, &m); err != nil {
return nil, err
}
for _, v := range m {
return v, nil
}
return nil, fmt.Errorf("Unable to extract the raw value from:\n\n%s\n\n", string(b))
}
|
go
|
func getRawValue(b json.RawMessage) (json.RawMessage, error) {
var m map[string]json.RawMessage
if err := json.Unmarshal(b, &m); err != nil {
return nil, err
}
for _, v := range m {
return v, nil
}
return nil, fmt.Errorf("Unable to extract the raw value from:\n\n%s\n\n", string(b))
}
|
[
"func",
"getRawValue",
"(",
"b",
"json",
".",
"RawMessage",
")",
"(",
"json",
".",
"RawMessage",
",",
"error",
")",
"{",
"var",
"m",
"map",
"[",
"string",
"]",
"json",
".",
"RawMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"m",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\\n",
"\"",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}"
] |
// Generic function to get the first raw value from a response as json.RawMessage
|
[
"Generic",
"function",
"to",
"get",
"the",
"first",
"raw",
"value",
"from",
"a",
"response",
"as",
"json",
".",
"RawMessage"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/cloudstack.go#L411-L420
|
145,831 |
xanzy/go-cloudstack
|
cloudstack/cloudstack.go
|
WithDomain
|
func WithDomain(domain string) OptionFunc {
return func(cs *CloudStackClient, p interface{}) error {
ps, ok := p.(DomainIDSetter)
if !ok || domain == "" {
return nil
}
if !IsID(domain) {
id, _, err := cs.Domain.GetDomainID(domain)
if err != nil {
return err
}
domain = id
}
ps.SetDomainid(domain)
return nil
}
}
|
go
|
func WithDomain(domain string) OptionFunc {
return func(cs *CloudStackClient, p interface{}) error {
ps, ok := p.(DomainIDSetter)
if !ok || domain == "" {
return nil
}
if !IsID(domain) {
id, _, err := cs.Domain.GetDomainID(domain)
if err != nil {
return err
}
domain = id
}
ps.SetDomainid(domain)
return nil
}
}
|
[
"func",
"WithDomain",
"(",
"domain",
"string",
")",
"OptionFunc",
"{",
"return",
"func",
"(",
"cs",
"*",
"CloudStackClient",
",",
"p",
"interface",
"{",
"}",
")",
"error",
"{",
"ps",
",",
"ok",
":=",
"p",
".",
"(",
"DomainIDSetter",
")",
"\n\n",
"if",
"!",
"ok",
"||",
"domain",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"!",
"IsID",
"(",
"domain",
")",
"{",
"id",
",",
"_",
",",
"err",
":=",
"cs",
".",
"Domain",
".",
"GetDomainID",
"(",
"domain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"domain",
"=",
"id",
"\n",
"}",
"\n\n",
"ps",
".",
"SetDomainid",
"(",
"domain",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// WithDomain takes either a domain name or ID and sets the `domainid` parameter
|
[
"WithDomain",
"takes",
"either",
"a",
"domain",
"name",
"or",
"ID",
"and",
"sets",
"the",
"domainid",
"parameter"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/cloudstack.go#L428-L448
|
145,832 |
xanzy/go-cloudstack
|
cloudstack/cloudstack.go
|
WithProject
|
func WithProject(project string) OptionFunc {
return func(cs *CloudStackClient, p interface{}) error {
ps, ok := p.(ProjectIDSetter)
if !ok || project == "" {
return nil
}
if !IsID(project) {
id, _, err := cs.Project.GetProjectID(project)
if err != nil {
return err
}
project = id
}
ps.SetProjectid(project)
return nil
}
}
|
go
|
func WithProject(project string) OptionFunc {
return func(cs *CloudStackClient, p interface{}) error {
ps, ok := p.(ProjectIDSetter)
if !ok || project == "" {
return nil
}
if !IsID(project) {
id, _, err := cs.Project.GetProjectID(project)
if err != nil {
return err
}
project = id
}
ps.SetProjectid(project)
return nil
}
}
|
[
"func",
"WithProject",
"(",
"project",
"string",
")",
"OptionFunc",
"{",
"return",
"func",
"(",
"cs",
"*",
"CloudStackClient",
",",
"p",
"interface",
"{",
"}",
")",
"error",
"{",
"ps",
",",
"ok",
":=",
"p",
".",
"(",
"ProjectIDSetter",
")",
"\n\n",
"if",
"!",
"ok",
"||",
"project",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"!",
"IsID",
"(",
"project",
")",
"{",
"id",
",",
"_",
",",
"err",
":=",
"cs",
".",
"Project",
".",
"GetProjectID",
"(",
"project",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"project",
"=",
"id",
"\n",
"}",
"\n\n",
"ps",
".",
"SetProjectid",
"(",
"project",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// WithProject takes either a project name or ID and sets the `projectid` parameter
|
[
"WithProject",
"takes",
"either",
"a",
"project",
"name",
"or",
"ID",
"and",
"sets",
"the",
"projectid",
"parameter"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/cloudstack.go#L456-L476
|
145,833 |
xanzy/go-cloudstack
|
cloudstack/cloudstack.go
|
WithVPCID
|
func WithVPCID(id string) OptionFunc {
return func(cs *CloudStackClient, p interface{}) error {
vs, ok := p.(VPCIDSetter)
if !ok || id == "" {
return nil
}
vs.SetVpcid(id)
return nil
}
}
|
go
|
func WithVPCID(id string) OptionFunc {
return func(cs *CloudStackClient, p interface{}) error {
vs, ok := p.(VPCIDSetter)
if !ok || id == "" {
return nil
}
vs.SetVpcid(id)
return nil
}
}
|
[
"func",
"WithVPCID",
"(",
"id",
"string",
")",
"OptionFunc",
"{",
"return",
"func",
"(",
"cs",
"*",
"CloudStackClient",
",",
"p",
"interface",
"{",
"}",
")",
"error",
"{",
"vs",
",",
"ok",
":=",
"p",
".",
"(",
"VPCIDSetter",
")",
"\n\n",
"if",
"!",
"ok",
"||",
"id",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"vs",
".",
"SetVpcid",
"(",
"id",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// WithVPCID takes a vpc ID and sets the `vpcid` parameter
|
[
"WithVPCID",
"takes",
"a",
"vpc",
"ID",
"and",
"sets",
"the",
"vpcid",
"parameter"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/cloudstack.go#L484-L496
|
145,834 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
NewAddImageStoreParams
|
func (s *ImageStoreService) NewAddImageStoreParams(provider string) *AddImageStoreParams {
p := &AddImageStoreParams{}
p.p = make(map[string]interface{})
p.p["provider"] = provider
return p
}
|
go
|
func (s *ImageStoreService) NewAddImageStoreParams(provider string) *AddImageStoreParams {
p := &AddImageStoreParams{}
p.p = make(map[string]interface{})
p.p["provider"] = provider
return p
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"NewAddImageStoreParams",
"(",
"provider",
"string",
")",
"*",
"AddImageStoreParams",
"{",
"p",
":=",
"&",
"AddImageStoreParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"provider",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddImageStoreParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddImageStoreParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L100-L105
|
145,835 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
NewAddImageStoreS3Params
|
func (s *ImageStoreService) NewAddImageStoreS3Params(accesskey string, bucket string, endpoint string, secretkey string) *AddImageStoreS3Params {
p := &AddImageStoreS3Params{}
p.p = make(map[string]interface{})
p.p["accesskey"] = accesskey
p.p["bucket"] = bucket
p.p["endpoint"] = endpoint
p.p["secretkey"] = secretkey
return p
}
|
go
|
func (s *ImageStoreService) NewAddImageStoreS3Params(accesskey string, bucket string, endpoint string, secretkey string) *AddImageStoreS3Params {
p := &AddImageStoreS3Params{}
p.p = make(map[string]interface{})
p.p["accesskey"] = accesskey
p.p["bucket"] = bucket
p.p["endpoint"] = endpoint
p.p["secretkey"] = secretkey
return p
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"NewAddImageStoreS3Params",
"(",
"accesskey",
"string",
",",
"bucket",
"string",
",",
"endpoint",
"string",
",",
"secretkey",
"string",
")",
"*",
"AddImageStoreS3Params",
"{",
"p",
":=",
"&",
"AddImageStoreS3Params",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"accesskey",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"bucket",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"endpoint",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"secretkey",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddImageStoreS3Params instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddImageStoreS3Params",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L274-L282
|
145,836 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
AddImageStoreS3
|
func (s *ImageStoreService) AddImageStoreS3(p *AddImageStoreS3Params) (*AddImageStoreS3Response, error) {
resp, err := s.cs.newRequest("addImageStoreS3", p.toURLValues())
if err != nil {
return nil, err
}
var r AddImageStoreS3Response
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *ImageStoreService) AddImageStoreS3(p *AddImageStoreS3Params) (*AddImageStoreS3Response, error) {
resp, err := s.cs.newRequest("addImageStoreS3", p.toURLValues())
if err != nil {
return nil, err
}
var r AddImageStoreS3Response
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"AddImageStoreS3",
"(",
"p",
"*",
"AddImageStoreS3Params",
")",
"(",
"*",
"AddImageStoreS3Response",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddImageStoreS3Response",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Adds S3 Image Store
|
[
"Adds",
"S3",
"Image",
"Store"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L285-L297
|
145,837 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
NewCreateSecondaryStagingStoreParams
|
func (s *ImageStoreService) NewCreateSecondaryStagingStoreParams(url string) *CreateSecondaryStagingStoreParams {
p := &CreateSecondaryStagingStoreParams{}
p.p = make(map[string]interface{})
p.p["url"] = url
return p
}
|
go
|
func (s *ImageStoreService) NewCreateSecondaryStagingStoreParams(url string) *CreateSecondaryStagingStoreParams {
p := &CreateSecondaryStagingStoreParams{}
p.p = make(map[string]interface{})
p.p["url"] = url
return p
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"NewCreateSecondaryStagingStoreParams",
"(",
"url",
"string",
")",
"*",
"CreateSecondaryStagingStoreParams",
"{",
"p",
":=",
"&",
"CreateSecondaryStagingStoreParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"url",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CreateSecondaryStagingStoreParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CreateSecondaryStagingStoreParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L383-L388
|
145,838 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
NewDeleteImageStoreParams
|
func (s *ImageStoreService) NewDeleteImageStoreParams(id string) *DeleteImageStoreParams {
p := &DeleteImageStoreParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *ImageStoreService) NewDeleteImageStoreParams(id string) *DeleteImageStoreParams {
p := &DeleteImageStoreParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"NewDeleteImageStoreParams",
"(",
"id",
"string",
")",
"*",
"DeleteImageStoreParams",
"{",
"p",
":=",
"&",
"DeleteImageStoreParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DeleteImageStoreParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteImageStoreParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L441-L446
|
145,839 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
DeleteImageStore
|
func (s *ImageStoreService) DeleteImageStore(p *DeleteImageStoreParams) (*DeleteImageStoreResponse, error) {
resp, err := s.cs.newRequest("deleteImageStore", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteImageStoreResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *ImageStoreService) DeleteImageStore(p *DeleteImageStoreParams) (*DeleteImageStoreResponse, error) {
resp, err := s.cs.newRequest("deleteImageStore", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteImageStoreResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"DeleteImageStore",
"(",
"p",
"*",
"DeleteImageStoreParams",
")",
"(",
"*",
"DeleteImageStoreResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeleteImageStoreResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Deletes an image store or Secondary Storage.
|
[
"Deletes",
"an",
"image",
"store",
"or",
"Secondary",
"Storage",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L449-L461
|
145,840 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
NewDeleteSecondaryStagingStoreParams
|
func (s *ImageStoreService) NewDeleteSecondaryStagingStoreParams(id string) *DeleteSecondaryStagingStoreParams {
p := &DeleteSecondaryStagingStoreParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *ImageStoreService) NewDeleteSecondaryStagingStoreParams(id string) *DeleteSecondaryStagingStoreParams {
p := &DeleteSecondaryStagingStoreParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"NewDeleteSecondaryStagingStoreParams",
"(",
"id",
"string",
")",
"*",
"DeleteSecondaryStagingStoreParams",
"{",
"p",
":=",
"&",
"DeleteSecondaryStagingStoreParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DeleteSecondaryStagingStoreParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteSecondaryStagingStoreParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L512-L517
|
145,841 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
NewListImageStoresParams
|
func (s *ImageStoreService) NewListImageStoresParams() *ListImageStoresParams {
p := &ListImageStoresParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *ImageStoreService) NewListImageStoresParams() *ListImageStoresParams {
p := &ListImageStoresParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"NewListImageStoresParams",
"(",
")",
"*",
"ListImageStoresParams",
"{",
"p",
":=",
"&",
"ListImageStoresParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListImageStoresParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListImageStoresParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L662-L666
|
145,842 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
NewListSecondaryStagingStoresParams
|
func (s *ImageStoreService) NewListSecondaryStagingStoresParams() *ListSecondaryStagingStoresParams {
p := &ListSecondaryStagingStoresParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *ImageStoreService) NewListSecondaryStagingStoresParams() *ListSecondaryStagingStoresParams {
p := &ListSecondaryStagingStoresParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"NewListSecondaryStagingStoresParams",
"(",
")",
"*",
"ListSecondaryStagingStoresParams",
"{",
"p",
":=",
"&",
"ListSecondaryStagingStoresParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListSecondaryStagingStoresParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListSecondaryStagingStoresParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L886-L890
|
145,843 |
xanzy/go-cloudstack
|
cloudstack/ImageStoreService.go
|
NewUpdateCloudToUseObjectStoreParams
|
func (s *ImageStoreService) NewUpdateCloudToUseObjectStoreParams(provider string) *UpdateCloudToUseObjectStoreParams {
p := &UpdateCloudToUseObjectStoreParams{}
p.p = make(map[string]interface{})
p.p["provider"] = provider
return p
}
|
go
|
func (s *ImageStoreService) NewUpdateCloudToUseObjectStoreParams(provider string) *UpdateCloudToUseObjectStoreParams {
p := &UpdateCloudToUseObjectStoreParams{}
p.p = make(map[string]interface{})
p.p["provider"] = provider
return p
}
|
[
"func",
"(",
"s",
"*",
"ImageStoreService",
")",
"NewUpdateCloudToUseObjectStoreParams",
"(",
"provider",
"string",
")",
"*",
"UpdateCloudToUseObjectStoreParams",
"{",
"p",
":=",
"&",
"UpdateCloudToUseObjectStoreParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"provider",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateCloudToUseObjectStoreParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateCloudToUseObjectStoreParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ImageStoreService.go#L1068-L1073
|
145,844 |
xanzy/go-cloudstack
|
cloudstack/APIDiscoveryService.go
|
NewListApisParams
|
func (s *APIDiscoveryService) NewListApisParams() *ListApisParams {
p := &ListApisParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *APIDiscoveryService) NewListApisParams() *ListApisParams {
p := &ListApisParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"APIDiscoveryService",
")",
"NewListApisParams",
"(",
")",
"*",
"ListApisParams",
"{",
"p",
":=",
"&",
"ListApisParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListApisParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListApisParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/APIDiscoveryService.go#L49-L53
|
145,845 |
xanzy/go-cloudstack
|
cloudstack/APIDiscoveryService.go
|
ListApis
|
func (s *APIDiscoveryService) ListApis(p *ListApisParams) (*ListApisResponse, error) {
resp, err := s.cs.newRequest("listApis", p.toURLValues())
if err != nil {
return nil, err
}
var r ListApisResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *APIDiscoveryService) ListApis(p *ListApisParams) (*ListApisResponse, error) {
resp, err := s.cs.newRequest("listApis", p.toURLValues())
if err != nil {
return nil, err
}
var r ListApisResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"APIDiscoveryService",
")",
"ListApis",
"(",
"p",
"*",
"ListApisParams",
")",
"(",
"*",
"ListApisResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListApisResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// lists all available apis on the server, provided by the Api Discovery plugin
|
[
"lists",
"all",
"available",
"apis",
"on",
"the",
"server",
"provided",
"by",
"the",
"Api",
"Discovery",
"plugin"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/APIDiscoveryService.go#L56-L68
|
145,846 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
NewCreateSSHKeyPairParams
|
func (s *SSHService) NewCreateSSHKeyPairParams(name string) *CreateSSHKeyPairParams {
p := &CreateSSHKeyPairParams{}
p.p = make(map[string]interface{})
p.p["name"] = name
return p
}
|
go
|
func (s *SSHService) NewCreateSSHKeyPairParams(name string) *CreateSSHKeyPairParams {
p := &CreateSSHKeyPairParams{}
p.p = make(map[string]interface{})
p.p["name"] = name
return p
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"NewCreateSSHKeyPairParams",
"(",
"name",
"string",
")",
"*",
"CreateSSHKeyPairParams",
"{",
"p",
":=",
"&",
"CreateSSHKeyPairParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CreateSSHKeyPairParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CreateSSHKeyPairParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L83-L88
|
145,847 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
CreateSSHKeyPair
|
func (s *SSHService) CreateSSHKeyPair(p *CreateSSHKeyPairParams) (*CreateSSHKeyPairResponse, error) {
resp, err := s.cs.newRequest("createSSHKeyPair", p.toURLValues())
if err != nil {
return nil, err
}
if resp, err = getRawValue(resp); err != nil {
return nil, err
}
var r CreateSSHKeyPairResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *SSHService) CreateSSHKeyPair(p *CreateSSHKeyPairParams) (*CreateSSHKeyPairResponse, error) {
resp, err := s.cs.newRequest("createSSHKeyPair", p.toURLValues())
if err != nil {
return nil, err
}
if resp, err = getRawValue(resp); err != nil {
return nil, err
}
var r CreateSSHKeyPairResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"CreateSSHKeyPair",
"(",
"p",
"*",
"CreateSSHKeyPairParams",
")",
"(",
"*",
"CreateSSHKeyPairResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"resp",
",",
"err",
"=",
"getRawValue",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"CreateSSHKeyPairResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Create a new keypair and returns the private key
|
[
"Create",
"a",
"new",
"keypair",
"and",
"returns",
"the",
"private",
"key"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L91-L107
|
145,848 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
NewDeleteSSHKeyPairParams
|
func (s *SSHService) NewDeleteSSHKeyPairParams(name string) *DeleteSSHKeyPairParams {
p := &DeleteSSHKeyPairParams{}
p.p = make(map[string]interface{})
p.p["name"] = name
return p
}
|
go
|
func (s *SSHService) NewDeleteSSHKeyPairParams(name string) *DeleteSSHKeyPairParams {
p := &DeleteSSHKeyPairParams{}
p.p = make(map[string]interface{})
p.p["name"] = name
return p
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"NewDeleteSSHKeyPairParams",
"(",
"name",
"string",
")",
"*",
"DeleteSSHKeyPairParams",
"{",
"p",
":=",
"&",
"DeleteSSHKeyPairParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DeleteSSHKeyPairParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteSSHKeyPairParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L171-L176
|
145,849 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
DeleteSSHKeyPair
|
func (s *SSHService) DeleteSSHKeyPair(p *DeleteSSHKeyPairParams) (*DeleteSSHKeyPairResponse, error) {
resp, err := s.cs.newRequest("deleteSSHKeyPair", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteSSHKeyPairResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *SSHService) DeleteSSHKeyPair(p *DeleteSSHKeyPairParams) (*DeleteSSHKeyPairResponse, error) {
resp, err := s.cs.newRequest("deleteSSHKeyPair", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteSSHKeyPairResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"DeleteSSHKeyPair",
"(",
"p",
"*",
"DeleteSSHKeyPairParams",
")",
"(",
"*",
"DeleteSSHKeyPairResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeleteSSHKeyPairResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Deletes a keypair by name
|
[
"Deletes",
"a",
"keypair",
"by",
"name"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L179-L191
|
145,850 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
NewListSSHKeyPairsParams
|
func (s *SSHService) NewListSSHKeyPairsParams() *ListSSHKeyPairsParams {
p := &ListSSHKeyPairsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *SSHService) NewListSSHKeyPairsParams() *ListSSHKeyPairsParams {
p := &ListSSHKeyPairsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"NewListSSHKeyPairsParams",
"(",
")",
"*",
"ListSSHKeyPairsParams",
"{",
"p",
":=",
"&",
"ListSSHKeyPairsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListSSHKeyPairsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListSSHKeyPairsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L345-L349
|
145,851 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
ListSSHKeyPairs
|
func (s *SSHService) ListSSHKeyPairs(p *ListSSHKeyPairsParams) (*ListSSHKeyPairsResponse, error) {
resp, err := s.cs.newRequest("listSSHKeyPairs", p.toURLValues())
if err != nil {
return nil, err
}
var r ListSSHKeyPairsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *SSHService) ListSSHKeyPairs(p *ListSSHKeyPairsParams) (*ListSSHKeyPairsResponse, error) {
resp, err := s.cs.newRequest("listSSHKeyPairs", p.toURLValues())
if err != nil {
return nil, err
}
var r ListSSHKeyPairsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"ListSSHKeyPairs",
"(",
"p",
"*",
"ListSSHKeyPairsParams",
")",
"(",
"*",
"ListSSHKeyPairsResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListSSHKeyPairsResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// List registered keypairs
|
[
"List",
"registered",
"keypairs"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L352-L364
|
145,852 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
NewRegisterSSHKeyPairParams
|
func (s *SSHService) NewRegisterSSHKeyPairParams(name string, publickey string) *RegisterSSHKeyPairParams {
p := &RegisterSSHKeyPairParams{}
p.p = make(map[string]interface{})
p.p["name"] = name
p.p["publickey"] = publickey
return p
}
|
go
|
func (s *SSHService) NewRegisterSSHKeyPairParams(name string, publickey string) *RegisterSSHKeyPairParams {
p := &RegisterSSHKeyPairParams{}
p.p = make(map[string]interface{})
p.p["name"] = name
p.p["publickey"] = publickey
return p
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"NewRegisterSSHKeyPairParams",
"(",
"name",
"string",
",",
"publickey",
"string",
")",
"*",
"RegisterSSHKeyPairParams",
"{",
"p",
":=",
"&",
"RegisterSSHKeyPairParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"publickey",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new RegisterSSHKeyPairParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"RegisterSSHKeyPairParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L448-L454
|
145,853 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
RegisterSSHKeyPair
|
func (s *SSHService) RegisterSSHKeyPair(p *RegisterSSHKeyPairParams) (*RegisterSSHKeyPairResponse, error) {
resp, err := s.cs.newRequest("registerSSHKeyPair", p.toURLValues())
if err != nil {
return nil, err
}
if resp, err = getRawValue(resp); err != nil {
return nil, err
}
var r RegisterSSHKeyPairResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *SSHService) RegisterSSHKeyPair(p *RegisterSSHKeyPairParams) (*RegisterSSHKeyPairResponse, error) {
resp, err := s.cs.newRequest("registerSSHKeyPair", p.toURLValues())
if err != nil {
return nil, err
}
if resp, err = getRawValue(resp); err != nil {
return nil, err
}
var r RegisterSSHKeyPairResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"RegisterSSHKeyPair",
"(",
"p",
"*",
"RegisterSSHKeyPairParams",
")",
"(",
"*",
"RegisterSSHKeyPairResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"resp",
",",
"err",
"=",
"getRawValue",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"RegisterSSHKeyPairResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Register a public key in a keypair under a certain name
|
[
"Register",
"a",
"public",
"key",
"in",
"a",
"keypair",
"under",
"a",
"certain",
"name"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L457-L473
|
145,854 |
xanzy/go-cloudstack
|
cloudstack/SSHService.go
|
NewResetSSHKeyForVirtualMachineParams
|
func (s *SSHService) NewResetSSHKeyForVirtualMachineParams(id string, keypair string) *ResetSSHKeyForVirtualMachineParams {
p := &ResetSSHKeyForVirtualMachineParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["keypair"] = keypair
return p
}
|
go
|
func (s *SSHService) NewResetSSHKeyForVirtualMachineParams(id string, keypair string) *ResetSSHKeyForVirtualMachineParams {
p := &ResetSSHKeyForVirtualMachineParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["keypair"] = keypair
return p
}
|
[
"func",
"(",
"s",
"*",
"SSHService",
")",
"NewResetSSHKeyForVirtualMachineParams",
"(",
"id",
"string",
",",
"keypair",
"string",
")",
"*",
"ResetSSHKeyForVirtualMachineParams",
"{",
"p",
":=",
"&",
"ResetSSHKeyForVirtualMachineParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"keypair",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ResetSSHKeyForVirtualMachineParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ResetSSHKeyForVirtualMachineParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SSHService.go#L552-L558
|
145,855 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewAddClusterParams
|
func (s *ClusterService) NewAddClusterParams(clustername string, clustertype string, hypervisor string, podid string, zoneid string) *AddClusterParams {
p := &AddClusterParams{}
p.p = make(map[string]interface{})
p.p["clustername"] = clustername
p.p["clustertype"] = clustertype
p.p["hypervisor"] = hypervisor
p.p["podid"] = podid
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *ClusterService) NewAddClusterParams(clustername string, clustertype string, hypervisor string, podid string, zoneid string) *AddClusterParams {
p := &AddClusterParams{}
p.p = make(map[string]interface{})
p.p["clustername"] = clustername
p.p["clustertype"] = clustertype
p.p["hypervisor"] = hypervisor
p.p["podid"] = podid
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewAddClusterParams",
"(",
"clustername",
"string",
",",
"clustertype",
"string",
",",
"hypervisor",
"string",
",",
"podid",
"string",
",",
"zoneid",
"string",
")",
"*",
"AddClusterParams",
"{",
"p",
":=",
"&",
"AddClusterParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"clustername",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"clustertype",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"hypervisor",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"podid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddClusterParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddClusterParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L250-L259
|
145,856 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewDedicateClusterParams
|
func (s *ClusterService) NewDedicateClusterParams(clusterid string, domainid string) *DedicateClusterParams {
p := &DedicateClusterParams{}
p.p = make(map[string]interface{})
p.p["clusterid"] = clusterid
p.p["domainid"] = domainid
return p
}
|
go
|
func (s *ClusterService) NewDedicateClusterParams(clusterid string, domainid string) *DedicateClusterParams {
p := &DedicateClusterParams{}
p.p = make(map[string]interface{})
p.p["clusterid"] = clusterid
p.p["domainid"] = domainid
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewDedicateClusterParams",
"(",
"clusterid",
"string",
",",
"domainid",
"string",
")",
"*",
"DedicateClusterParams",
"{",
"p",
":=",
"&",
"DedicateClusterParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"clusterid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"domainid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DedicateClusterParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DedicateClusterParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L356-L362
|
145,857 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewDeleteClusterParams
|
func (s *ClusterService) NewDeleteClusterParams(id string) *DeleteClusterParams {
p := &DeleteClusterParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *ClusterService) NewDeleteClusterParams(id string) *DeleteClusterParams {
p := &DeleteClusterParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewDeleteClusterParams",
"(",
"id",
"string",
")",
"*",
"DeleteClusterParams",
"{",
"p",
":=",
"&",
"DeleteClusterParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DeleteClusterParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteClusterParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L434-L439
|
145,858 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewDisableOutOfBandManagementForClusterParams
|
func (s *ClusterService) NewDisableOutOfBandManagementForClusterParams(clusterid string) *DisableOutOfBandManagementForClusterParams {
p := &DisableOutOfBandManagementForClusterParams{}
p.p = make(map[string]interface{})
p.p["clusterid"] = clusterid
return p
}
|
go
|
func (s *ClusterService) NewDisableOutOfBandManagementForClusterParams(clusterid string) *DisableOutOfBandManagementForClusterParams {
p := &DisableOutOfBandManagementForClusterParams{}
p.p = make(map[string]interface{})
p.p["clusterid"] = clusterid
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewDisableOutOfBandManagementForClusterParams",
"(",
"clusterid",
"string",
")",
"*",
"DisableOutOfBandManagementForClusterParams",
"{",
"p",
":=",
"&",
"DisableOutOfBandManagementForClusterParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"clusterid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DisableOutOfBandManagementForClusterParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DisableOutOfBandManagementForClusterParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L505-L510
|
145,859 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
DisableOutOfBandManagementForCluster
|
func (s *ClusterService) DisableOutOfBandManagementForCluster(p *DisableOutOfBandManagementForClusterParams) (*DisableOutOfBandManagementForClusterResponse, error) {
resp, err := s.cs.newRequest("disableOutOfBandManagementForCluster", p.toURLValues())
if err != nil {
return nil, err
}
var r DisableOutOfBandManagementForClusterResponse
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
}
|
go
|
func (s *ClusterService) DisableOutOfBandManagementForCluster(p *DisableOutOfBandManagementForClusterParams) (*DisableOutOfBandManagementForClusterResponse, error) {
resp, err := s.cs.newRequest("disableOutOfBandManagementForCluster", p.toURLValues())
if err != nil {
return nil, err
}
var r DisableOutOfBandManagementForClusterResponse
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
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"DisableOutOfBandManagementForCluster",
"(",
"p",
"*",
"DisableOutOfBandManagementForClusterParams",
")",
"(",
"*",
"DisableOutOfBandManagementForClusterResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DisableOutOfBandManagementForClusterResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Disables out-of-band management for a cluster
|
[
"Disables",
"out",
"-",
"of",
"-",
"band",
"management",
"for",
"a",
"cluster"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L513-L545
|
145,860 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewEnableOutOfBandManagementForClusterParams
|
func (s *ClusterService) NewEnableOutOfBandManagementForClusterParams(clusterid string) *EnableOutOfBandManagementForClusterParams {
p := &EnableOutOfBandManagementForClusterParams{}
p.p = make(map[string]interface{})
p.p["clusterid"] = clusterid
return p
}
|
go
|
func (s *ClusterService) NewEnableOutOfBandManagementForClusterParams(clusterid string) *EnableOutOfBandManagementForClusterParams {
p := &EnableOutOfBandManagementForClusterParams{}
p.p = make(map[string]interface{})
p.p["clusterid"] = clusterid
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewEnableOutOfBandManagementForClusterParams",
"(",
"clusterid",
"string",
")",
"*",
"EnableOutOfBandManagementForClusterParams",
"{",
"p",
":=",
"&",
"EnableOutOfBandManagementForClusterParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"clusterid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new EnableOutOfBandManagementForClusterParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"EnableOutOfBandManagementForClusterParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L587-L592
|
145,861 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
EnableOutOfBandManagementForCluster
|
func (s *ClusterService) EnableOutOfBandManagementForCluster(p *EnableOutOfBandManagementForClusterParams) (*EnableOutOfBandManagementForClusterResponse, error) {
resp, err := s.cs.newRequest("enableOutOfBandManagementForCluster", p.toURLValues())
if err != nil {
return nil, err
}
var r EnableOutOfBandManagementForClusterResponse
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
}
|
go
|
func (s *ClusterService) EnableOutOfBandManagementForCluster(p *EnableOutOfBandManagementForClusterParams) (*EnableOutOfBandManagementForClusterResponse, error) {
resp, err := s.cs.newRequest("enableOutOfBandManagementForCluster", p.toURLValues())
if err != nil {
return nil, err
}
var r EnableOutOfBandManagementForClusterResponse
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
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"EnableOutOfBandManagementForCluster",
"(",
"p",
"*",
"EnableOutOfBandManagementForClusterParams",
")",
"(",
"*",
"EnableOutOfBandManagementForClusterResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"EnableOutOfBandManagementForClusterResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Enables out-of-band management for a cluster
|
[
"Enables",
"out",
"-",
"of",
"-",
"band",
"management",
"for",
"a",
"cluster"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L595-L627
|
145,862 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewListClustersParams
|
func (s *ClusterService) NewListClustersParams() *ListClustersParams {
p := &ListClustersParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *ClusterService) NewListClustersParams() *ListClustersParams {
p := &ListClustersParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewListClustersParams",
"(",
")",
"*",
"ListClustersParams",
"{",
"p",
":=",
"&",
"ListClustersParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListClustersParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListClustersParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L793-L797
|
145,863 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewListDedicatedClustersParams
|
func (s *ClusterService) NewListDedicatedClustersParams() *ListDedicatedClustersParams {
p := &ListDedicatedClustersParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *ClusterService) NewListDedicatedClustersParams() *ListDedicatedClustersParams {
p := &ListDedicatedClustersParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewListDedicatedClustersParams",
"(",
")",
"*",
"ListDedicatedClustersParams",
"{",
"p",
":=",
"&",
"ListDedicatedClustersParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListDedicatedClustersParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListDedicatedClustersParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L1028-L1032
|
145,864 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewReleaseDedicatedClusterParams
|
func (s *ClusterService) NewReleaseDedicatedClusterParams(clusterid string) *ReleaseDedicatedClusterParams {
p := &ReleaseDedicatedClusterParams{}
p.p = make(map[string]interface{})
p.p["clusterid"] = clusterid
return p
}
|
go
|
func (s *ClusterService) NewReleaseDedicatedClusterParams(clusterid string) *ReleaseDedicatedClusterParams {
p := &ReleaseDedicatedClusterParams{}
p.p = make(map[string]interface{})
p.p["clusterid"] = clusterid
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewReleaseDedicatedClusterParams",
"(",
"clusterid",
"string",
")",
"*",
"ReleaseDedicatedClusterParams",
"{",
"p",
":=",
"&",
"ReleaseDedicatedClusterParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"clusterid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ReleaseDedicatedClusterParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ReleaseDedicatedClusterParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L1088-L1093
|
145,865 |
xanzy/go-cloudstack
|
cloudstack/ClusterService.go
|
NewUpdateClusterParams
|
func (s *ClusterService) NewUpdateClusterParams(id string) *UpdateClusterParams {
p := &UpdateClusterParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *ClusterService) NewUpdateClusterParams(id string) *UpdateClusterParams {
p := &UpdateClusterParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"ClusterService",
")",
"NewUpdateClusterParams",
"(",
"id",
"string",
")",
"*",
"UpdateClusterParams",
"{",
"p",
":=",
"&",
"UpdateClusterParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateClusterParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateClusterParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ClusterService.go#L1211-L1216
|
145,866 |
xanzy/go-cloudstack
|
cloudstack/StoragePoolService.go
|
NewCancelStorageMaintenanceParams
|
func (s *StoragePoolService) NewCancelStorageMaintenanceParams(id string) *CancelStorageMaintenanceParams {
p := &CancelStorageMaintenanceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *StoragePoolService) NewCancelStorageMaintenanceParams(id string) *CancelStorageMaintenanceParams {
p := &CancelStorageMaintenanceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"StoragePoolService",
")",
"NewCancelStorageMaintenanceParams",
"(",
"id",
"string",
")",
"*",
"CancelStorageMaintenanceParams",
"{",
"p",
":=",
"&",
"CancelStorageMaintenanceParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CancelStorageMaintenanceParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CancelStorageMaintenanceParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/StoragePoolService.go#L50-L55
|
145,867 |
xanzy/go-cloudstack
|
cloudstack/StoragePoolService.go
|
NewEnableStorageMaintenanceParams
|
func (s *StoragePoolService) NewEnableStorageMaintenanceParams(id string) *EnableStorageMaintenanceParams {
p := &EnableStorageMaintenanceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *StoragePoolService) NewEnableStorageMaintenanceParams(id string) *EnableStorageMaintenanceParams {
p := &EnableStorageMaintenanceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"StoragePoolService",
")",
"NewEnableStorageMaintenanceParams",
"(",
"id",
"string",
")",
"*",
"EnableStorageMaintenanceParams",
"{",
"p",
":=",
"&",
"EnableStorageMaintenanceParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new EnableStorageMaintenanceParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"EnableStorageMaintenanceParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/StoragePoolService.go#L146-L151
|
145,868 |
xanzy/go-cloudstack
|
cloudstack/StoragePoolService.go
|
NewListStorageProvidersParams
|
func (s *StoragePoolService) NewListStorageProvidersParams(storagePoolType string) *ListStorageProvidersParams {
p := &ListStorageProvidersParams{}
p.p = make(map[string]interface{})
p.p["type"] = storagePoolType
return p
}
|
go
|
func (s *StoragePoolService) NewListStorageProvidersParams(storagePoolType string) *ListStorageProvidersParams {
p := &ListStorageProvidersParams{}
p.p = make(map[string]interface{})
p.p["type"] = storagePoolType
return p
}
|
[
"func",
"(",
"s",
"*",
"StoragePoolService",
")",
"NewListStorageProvidersParams",
"(",
"storagePoolType",
"string",
")",
"*",
"ListStorageProvidersParams",
"{",
"p",
":=",
"&",
"ListStorageProvidersParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"storagePoolType",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListStorageProvidersParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListStorageProvidersParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/StoragePoolService.go#L277-L282
|
145,869 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewAddGuestOsParams
|
func (s *GuestOSService) NewAddGuestOsParams(details map[string]string, oscategoryid string, osdisplayname string) *AddGuestOsParams {
p := &AddGuestOsParams{}
p.p = make(map[string]interface{})
p.p["details"] = details
p.p["oscategoryid"] = oscategoryid
p.p["osdisplayname"] = osdisplayname
return p
}
|
go
|
func (s *GuestOSService) NewAddGuestOsParams(details map[string]string, oscategoryid string, osdisplayname string) *AddGuestOsParams {
p := &AddGuestOsParams{}
p.p = make(map[string]interface{})
p.p["details"] = details
p.p["oscategoryid"] = oscategoryid
p.p["osdisplayname"] = osdisplayname
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewAddGuestOsParams",
"(",
"details",
"map",
"[",
"string",
"]",
"string",
",",
"oscategoryid",
"string",
",",
"osdisplayname",
"string",
")",
"*",
"AddGuestOsParams",
"{",
"p",
":=",
"&",
"AddGuestOsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"details",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"oscategoryid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"osdisplayname",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddGuestOsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddGuestOsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L89-L96
|
145,870 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
AddGuestOs
|
func (s *GuestOSService) AddGuestOs(p *AddGuestOsParams) (*AddGuestOsResponse, error) {
resp, err := s.cs.newRequest("addGuestOs", p.toURLValues())
if err != nil {
return nil, err
}
var r AddGuestOsResponse
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
}
|
go
|
func (s *GuestOSService) AddGuestOs(p *AddGuestOsParams) (*AddGuestOsResponse, error) {
resp, err := s.cs.newRequest("addGuestOs", p.toURLValues())
if err != nil {
return nil, err
}
var r AddGuestOsResponse
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
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"AddGuestOs",
"(",
"p",
"*",
"AddGuestOsParams",
")",
"(",
"*",
"AddGuestOsResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddGuestOsResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Add a new guest OS type
|
[
"Add",
"a",
"new",
"guest",
"OS",
"type"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L99-L131
|
145,871 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewAddGuestOsMappingParams
|
func (s *GuestOSService) NewAddGuestOsMappingParams(hypervisor string, hypervisorversion string, osnameforhypervisor string) *AddGuestOsMappingParams {
p := &AddGuestOsMappingParams{}
p.p = make(map[string]interface{})
p.p["hypervisor"] = hypervisor
p.p["hypervisorversion"] = hypervisorversion
p.p["osnameforhypervisor"] = osnameforhypervisor
return p
}
|
go
|
func (s *GuestOSService) NewAddGuestOsMappingParams(hypervisor string, hypervisorversion string, osnameforhypervisor string) *AddGuestOsMappingParams {
p := &AddGuestOsMappingParams{}
p.p = make(map[string]interface{})
p.p["hypervisor"] = hypervisor
p.p["hypervisorversion"] = hypervisorversion
p.p["osnameforhypervisor"] = osnameforhypervisor
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewAddGuestOsMappingParams",
"(",
"hypervisor",
"string",
",",
"hypervisorversion",
"string",
",",
"osnameforhypervisor",
"string",
")",
"*",
"AddGuestOsMappingParams",
"{",
"p",
":=",
"&",
"AddGuestOsMappingParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"hypervisor",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"hypervisorversion",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"osnameforhypervisor",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddGuestOsMappingParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddGuestOsMappingParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L210-L217
|
145,872 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
AddGuestOsMapping
|
func (s *GuestOSService) AddGuestOsMapping(p *AddGuestOsMappingParams) (*AddGuestOsMappingResponse, error) {
resp, err := s.cs.newRequest("addGuestOsMapping", p.toURLValues())
if err != nil {
return nil, err
}
var r AddGuestOsMappingResponse
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
}
|
go
|
func (s *GuestOSService) AddGuestOsMapping(p *AddGuestOsMappingParams) (*AddGuestOsMappingResponse, error) {
resp, err := s.cs.newRequest("addGuestOsMapping", p.toURLValues())
if err != nil {
return nil, err
}
var r AddGuestOsMappingResponse
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
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"AddGuestOsMapping",
"(",
"p",
"*",
"AddGuestOsMappingParams",
")",
"(",
"*",
"AddGuestOsMappingResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddGuestOsMappingResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Adds a guest OS name to hypervisor OS name mapping
|
[
"Adds",
"a",
"guest",
"OS",
"name",
"to",
"hypervisor",
"OS",
"name",
"mapping"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L220-L252
|
145,873 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewListGuestOsMappingParams
|
func (s *GuestOSService) NewListGuestOsMappingParams() *ListGuestOsMappingParams {
p := &ListGuestOsMappingParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *GuestOSService) NewListGuestOsMappingParams() *ListGuestOsMappingParams {
p := &ListGuestOsMappingParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewListGuestOsMappingParams",
"(",
")",
"*",
"ListGuestOsMappingParams",
"{",
"p",
":=",
"&",
"ListGuestOsMappingParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListGuestOsMappingParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListGuestOsMappingParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L358-L362
|
145,874 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
ListGuestOsMapping
|
func (s *GuestOSService) ListGuestOsMapping(p *ListGuestOsMappingParams) (*ListGuestOsMappingResponse, error) {
resp, err := s.cs.newRequest("listGuestOsMapping", p.toURLValues())
if err != nil {
return nil, err
}
var r ListGuestOsMappingResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *GuestOSService) ListGuestOsMapping(p *ListGuestOsMappingParams) (*ListGuestOsMappingResponse, error) {
resp, err := s.cs.newRequest("listGuestOsMapping", p.toURLValues())
if err != nil {
return nil, err
}
var r ListGuestOsMappingResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"ListGuestOsMapping",
"(",
"p",
"*",
"ListGuestOsMappingParams",
")",
"(",
"*",
"ListGuestOsMappingResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListGuestOsMappingResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Lists all available OS mappings for given hypervisor
|
[
"Lists",
"all",
"available",
"OS",
"mappings",
"for",
"given",
"hypervisor"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L398-L410
|
145,875 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewListOsCategoriesParams
|
func (s *GuestOSService) NewListOsCategoriesParams() *ListOsCategoriesParams {
p := &ListOsCategoriesParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *GuestOSService) NewListOsCategoriesParams() *ListOsCategoriesParams {
p := &ListOsCategoriesParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewListOsCategoriesParams",
"(",
")",
"*",
"ListOsCategoriesParams",
"{",
"p",
":=",
"&",
"ListOsCategoriesParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListOsCategoriesParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListOsCategoriesParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L498-L502
|
145,876 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
ListOsCategories
|
func (s *GuestOSService) ListOsCategories(p *ListOsCategoriesParams) (*ListOsCategoriesResponse, error) {
resp, err := s.cs.newRequest("listOsCategories", p.toURLValues())
if err != nil {
return nil, err
}
var r ListOsCategoriesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *GuestOSService) ListOsCategories(p *ListOsCategoriesParams) (*ListOsCategoriesResponse, error) {
resp, err := s.cs.newRequest("listOsCategories", p.toURLValues())
if err != nil {
return nil, err
}
var r ListOsCategoriesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"ListOsCategories",
"(",
"p",
"*",
"ListOsCategoriesParams",
")",
"(",
"*",
"ListOsCategoriesResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListOsCategoriesResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Lists all supported OS categories for this cloud.
|
[
"Lists",
"all",
"supported",
"OS",
"categories",
"for",
"this",
"cloud",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L588-L600
|
145,877 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewListOsTypesParams
|
func (s *GuestOSService) NewListOsTypesParams() *ListOsTypesParams {
p := &ListOsTypesParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *GuestOSService) NewListOsTypesParams() *ListOsTypesParams {
p := &ListOsTypesParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewListOsTypesParams",
"(",
")",
"*",
"ListOsTypesParams",
"{",
"p",
":=",
"&",
"ListOsTypesParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListOsTypesParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListOsTypesParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L694-L698
|
145,878 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
ListOsTypes
|
func (s *GuestOSService) ListOsTypes(p *ListOsTypesParams) (*ListOsTypesResponse, error) {
resp, err := s.cs.newRequest("listOsTypes", p.toURLValues())
if err != nil {
return nil, err
}
var r ListOsTypesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *GuestOSService) ListOsTypes(p *ListOsTypesParams) (*ListOsTypesResponse, error) {
resp, err := s.cs.newRequest("listOsTypes", p.toURLValues())
if err != nil {
return nil, err
}
var r ListOsTypesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"ListOsTypes",
"(",
"p",
"*",
"ListOsTypesParams",
")",
"(",
"*",
"ListOsTypesResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListOsTypesResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Lists all supported OS types for this cloud.
|
[
"Lists",
"all",
"supported",
"OS",
"types",
"for",
"this",
"cloud",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L734-L746
|
145,879 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewRemoveGuestOsParams
|
func (s *GuestOSService) NewRemoveGuestOsParams(id string) *RemoveGuestOsParams {
p := &RemoveGuestOsParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *GuestOSService) NewRemoveGuestOsParams(id string) *RemoveGuestOsParams {
p := &RemoveGuestOsParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewRemoveGuestOsParams",
"(",
"id",
"string",
")",
"*",
"RemoveGuestOsParams",
"{",
"p",
":=",
"&",
"RemoveGuestOsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new RemoveGuestOsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"RemoveGuestOsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L785-L790
|
145,880 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
RemoveGuestOs
|
func (s *GuestOSService) RemoveGuestOs(p *RemoveGuestOsParams) (*RemoveGuestOsResponse, error) {
resp, err := s.cs.newRequest("removeGuestOs", p.toURLValues())
if err != nil {
return nil, err
}
var r RemoveGuestOsResponse
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
}
|
go
|
func (s *GuestOSService) RemoveGuestOs(p *RemoveGuestOsParams) (*RemoveGuestOsResponse, error) {
resp, err := s.cs.newRequest("removeGuestOs", p.toURLValues())
if err != nil {
return nil, err
}
var r RemoveGuestOsResponse
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
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"RemoveGuestOs",
"(",
"p",
"*",
"RemoveGuestOsParams",
")",
"(",
"*",
"RemoveGuestOsResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"RemoveGuestOsResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Removes a Guest OS from listing.
|
[
"Removes",
"a",
"Guest",
"OS",
"from",
"listing",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L793-L820
|
145,881 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewRemoveGuestOsMappingParams
|
func (s *GuestOSService) NewRemoveGuestOsMappingParams(id string) *RemoveGuestOsMappingParams {
p := &RemoveGuestOsMappingParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *GuestOSService) NewRemoveGuestOsMappingParams(id string) *RemoveGuestOsMappingParams {
p := &RemoveGuestOsMappingParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewRemoveGuestOsMappingParams",
"(",
"id",
"string",
")",
"*",
"RemoveGuestOsMappingParams",
"{",
"p",
":=",
"&",
"RemoveGuestOsMappingParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new RemoveGuestOsMappingParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"RemoveGuestOsMappingParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L853-L858
|
145,882 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
RemoveGuestOsMapping
|
func (s *GuestOSService) RemoveGuestOsMapping(p *RemoveGuestOsMappingParams) (*RemoveGuestOsMappingResponse, error) {
resp, err := s.cs.newRequest("removeGuestOsMapping", p.toURLValues())
if err != nil {
return nil, err
}
var r RemoveGuestOsMappingResponse
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
}
|
go
|
func (s *GuestOSService) RemoveGuestOsMapping(p *RemoveGuestOsMappingParams) (*RemoveGuestOsMappingResponse, error) {
resp, err := s.cs.newRequest("removeGuestOsMapping", p.toURLValues())
if err != nil {
return nil, err
}
var r RemoveGuestOsMappingResponse
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
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"RemoveGuestOsMapping",
"(",
"p",
"*",
"RemoveGuestOsMappingParams",
")",
"(",
"*",
"RemoveGuestOsMappingResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"RemoveGuestOsMappingResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Removes a Guest OS Mapping.
|
[
"Removes",
"a",
"Guest",
"OS",
"Mapping",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L861-L888
|
145,883 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewUpdateGuestOsParams
|
func (s *GuestOSService) NewUpdateGuestOsParams(details map[string]string, id string, osdisplayname string) *UpdateGuestOsParams {
p := &UpdateGuestOsParams{}
p.p = make(map[string]interface{})
p.p["details"] = details
p.p["id"] = id
p.p["osdisplayname"] = osdisplayname
return p
}
|
go
|
func (s *GuestOSService) NewUpdateGuestOsParams(details map[string]string, id string, osdisplayname string) *UpdateGuestOsParams {
p := &UpdateGuestOsParams{}
p.p = make(map[string]interface{})
p.p["details"] = details
p.p["id"] = id
p.p["osdisplayname"] = osdisplayname
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewUpdateGuestOsParams",
"(",
"details",
"map",
"[",
"string",
"]",
"string",
",",
"id",
"string",
",",
"osdisplayname",
"string",
")",
"*",
"UpdateGuestOsParams",
"{",
"p",
":=",
"&",
"UpdateGuestOsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"details",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"osdisplayname",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateGuestOsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateGuestOsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L947-L954
|
145,884 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
UpdateGuestOs
|
func (s *GuestOSService) UpdateGuestOs(p *UpdateGuestOsParams) (*UpdateGuestOsResponse, error) {
resp, err := s.cs.newRequest("updateGuestOs", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateGuestOsResponse
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
}
|
go
|
func (s *GuestOSService) UpdateGuestOs(p *UpdateGuestOsParams) (*UpdateGuestOsResponse, error) {
resp, err := s.cs.newRequest("updateGuestOs", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateGuestOsResponse
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
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"UpdateGuestOs",
"(",
"p",
"*",
"UpdateGuestOsParams",
")",
"(",
"*",
"UpdateGuestOsResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"UpdateGuestOsResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Updates the information about Guest OS
|
[
"Updates",
"the",
"information",
"about",
"Guest",
"OS"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L957-L989
|
145,885 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
NewUpdateGuestOsMappingParams
|
func (s *GuestOSService) NewUpdateGuestOsMappingParams(id string, osnameforhypervisor string) *UpdateGuestOsMappingParams {
p := &UpdateGuestOsMappingParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["osnameforhypervisor"] = osnameforhypervisor
return p
}
|
go
|
func (s *GuestOSService) NewUpdateGuestOsMappingParams(id string, osnameforhypervisor string) *UpdateGuestOsMappingParams {
p := &UpdateGuestOsMappingParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["osnameforhypervisor"] = osnameforhypervisor
return p
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"NewUpdateGuestOsMappingParams",
"(",
"id",
"string",
",",
"osnameforhypervisor",
"string",
")",
"*",
"UpdateGuestOsMappingParams",
"{",
"p",
":=",
"&",
"UpdateGuestOsMappingParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"osnameforhypervisor",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateGuestOsMappingParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateGuestOsMappingParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L1035-L1041
|
145,886 |
xanzy/go-cloudstack
|
cloudstack/GuestOSService.go
|
UpdateGuestOsMapping
|
func (s *GuestOSService) UpdateGuestOsMapping(p *UpdateGuestOsMappingParams) (*UpdateGuestOsMappingResponse, error) {
resp, err := s.cs.newRequest("updateGuestOsMapping", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateGuestOsMappingResponse
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
}
|
go
|
func (s *GuestOSService) UpdateGuestOsMapping(p *UpdateGuestOsMappingParams) (*UpdateGuestOsMappingResponse, error) {
resp, err := s.cs.newRequest("updateGuestOsMapping", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateGuestOsMappingResponse
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
}
|
[
"func",
"(",
"s",
"*",
"GuestOSService",
")",
"UpdateGuestOsMapping",
"(",
"p",
"*",
"UpdateGuestOsMappingParams",
")",
"(",
"*",
"UpdateGuestOsMappingResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"UpdateGuestOsMappingResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Updates the information about Guest OS to Hypervisor specific name mapping
|
[
"Updates",
"the",
"information",
"about",
"Guest",
"OS",
"to",
"Hypervisor",
"specific",
"name",
"mapping"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/GuestOSService.go#L1044-L1076
|
145,887 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
NewAddBaremetalDhcpParams
|
func (s *BaremetalService) NewAddBaremetalDhcpParams(dhcpservertype string, password string, physicalnetworkid string, url string, username string) *AddBaremetalDhcpParams {
p := &AddBaremetalDhcpParams{}
p.p = make(map[string]interface{})
p.p["dhcpservertype"] = dhcpservertype
p.p["password"] = password
p.p["physicalnetworkid"] = physicalnetworkid
p.p["url"] = url
p.p["username"] = username
return p
}
|
go
|
func (s *BaremetalService) NewAddBaremetalDhcpParams(dhcpservertype string, password string, physicalnetworkid string, url string, username string) *AddBaremetalDhcpParams {
p := &AddBaremetalDhcpParams{}
p.p = make(map[string]interface{})
p.p["dhcpservertype"] = dhcpservertype
p.p["password"] = password
p.p["physicalnetworkid"] = physicalnetworkid
p.p["url"] = url
p.p["username"] = username
return p
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"NewAddBaremetalDhcpParams",
"(",
"dhcpservertype",
"string",
",",
"password",
"string",
",",
"physicalnetworkid",
"string",
",",
"url",
"string",
",",
"username",
"string",
")",
"*",
"AddBaremetalDhcpParams",
"{",
"p",
":=",
"&",
"AddBaremetalDhcpParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"dhcpservertype",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"password",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"physicalnetworkid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"url",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"username",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddBaremetalDhcpParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddBaremetalDhcpParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L94-L103
|
145,888 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
AddBaremetalDhcp
|
func (s *BaremetalService) AddBaremetalDhcp(p *AddBaremetalDhcpParams) (*AddBaremetalDhcpResponse, error) {
resp, err := s.cs.newRequest("addBaremetalDhcp", p.toURLValues())
if err != nil {
return nil, err
}
var r AddBaremetalDhcpResponse
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
}
|
go
|
func (s *BaremetalService) AddBaremetalDhcp(p *AddBaremetalDhcpParams) (*AddBaremetalDhcpResponse, error) {
resp, err := s.cs.newRequest("addBaremetalDhcp", p.toURLValues())
if err != nil {
return nil, err
}
var r AddBaremetalDhcpResponse
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
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"AddBaremetalDhcp",
"(",
"p",
"*",
"AddBaremetalDhcpParams",
")",
"(",
"*",
"AddBaremetalDhcpResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddBaremetalDhcpResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// adds a baremetal dhcp server
|
[
"adds",
"a",
"baremetal",
"dhcp",
"server"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L106-L138
|
145,889 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
NewAddBaremetalPxeKickStartServerParams
|
func (s *BaremetalService) NewAddBaremetalPxeKickStartServerParams(password string, physicalnetworkid string, pxeservertype string, tftpdir string, url string, username string) *AddBaremetalPxeKickStartServerParams {
p := &AddBaremetalPxeKickStartServerParams{}
p.p = make(map[string]interface{})
p.p["password"] = password
p.p["physicalnetworkid"] = physicalnetworkid
p.p["pxeservertype"] = pxeservertype
p.p["tftpdir"] = tftpdir
p.p["url"] = url
p.p["username"] = username
return p
}
|
go
|
func (s *BaremetalService) NewAddBaremetalPxeKickStartServerParams(password string, physicalnetworkid string, pxeservertype string, tftpdir string, url string, username string) *AddBaremetalPxeKickStartServerParams {
p := &AddBaremetalPxeKickStartServerParams{}
p.p = make(map[string]interface{})
p.p["password"] = password
p.p["physicalnetworkid"] = physicalnetworkid
p.p["pxeservertype"] = pxeservertype
p.p["tftpdir"] = tftpdir
p.p["url"] = url
p.p["username"] = username
return p
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"NewAddBaremetalPxeKickStartServerParams",
"(",
"password",
"string",
",",
"physicalnetworkid",
"string",
",",
"pxeservertype",
"string",
",",
"tftpdir",
"string",
",",
"url",
"string",
",",
"username",
"string",
")",
"*",
"AddBaremetalPxeKickStartServerParams",
"{",
"p",
":=",
"&",
"AddBaremetalPxeKickStartServerParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"password",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"physicalnetworkid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"pxeservertype",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"tftpdir",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"url",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"username",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddBaremetalPxeKickStartServerParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddBaremetalPxeKickStartServerParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L240-L250
|
145,890 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
AddBaremetalPxeKickStartServer
|
func (s *BaremetalService) AddBaremetalPxeKickStartServer(p *AddBaremetalPxeKickStartServerParams) (*AddBaremetalPxeKickStartServerResponse, error) {
resp, err := s.cs.newRequest("addBaremetalPxeKickStartServer", p.toURLValues())
if err != nil {
return nil, err
}
var r AddBaremetalPxeKickStartServerResponse
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
}
|
go
|
func (s *BaremetalService) AddBaremetalPxeKickStartServer(p *AddBaremetalPxeKickStartServerParams) (*AddBaremetalPxeKickStartServerResponse, error) {
resp, err := s.cs.newRequest("addBaremetalPxeKickStartServer", p.toURLValues())
if err != nil {
return nil, err
}
var r AddBaremetalPxeKickStartServerResponse
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
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"AddBaremetalPxeKickStartServer",
"(",
"p",
"*",
"AddBaremetalPxeKickStartServerParams",
")",
"(",
"*",
"AddBaremetalPxeKickStartServerResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddBaremetalPxeKickStartServerResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// add a baremetal pxe server
|
[
"add",
"a",
"baremetal",
"pxe",
"server"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L253-L285
|
145,891 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
NewAddBaremetalPxePingServerParams
|
func (s *BaremetalService) NewAddBaremetalPxePingServerParams(password string, physicalnetworkid string, pingdir string, pingstorageserverip string, pxeservertype string, tftpdir string, url string, username string) *AddBaremetalPxePingServerParams {
p := &AddBaremetalPxePingServerParams{}
p.p = make(map[string]interface{})
p.p["password"] = password
p.p["physicalnetworkid"] = physicalnetworkid
p.p["pingdir"] = pingdir
p.p["pingstorageserverip"] = pingstorageserverip
p.p["pxeservertype"] = pxeservertype
p.p["tftpdir"] = tftpdir
p.p["url"] = url
p.p["username"] = username
return p
}
|
go
|
func (s *BaremetalService) NewAddBaremetalPxePingServerParams(password string, physicalnetworkid string, pingdir string, pingstorageserverip string, pxeservertype string, tftpdir string, url string, username string) *AddBaremetalPxePingServerParams {
p := &AddBaremetalPxePingServerParams{}
p.p = make(map[string]interface{})
p.p["password"] = password
p.p["physicalnetworkid"] = physicalnetworkid
p.p["pingdir"] = pingdir
p.p["pingstorageserverip"] = pingstorageserverip
p.p["pxeservertype"] = pxeservertype
p.p["tftpdir"] = tftpdir
p.p["url"] = url
p.p["username"] = username
return p
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"NewAddBaremetalPxePingServerParams",
"(",
"password",
"string",
",",
"physicalnetworkid",
"string",
",",
"pingdir",
"string",
",",
"pingstorageserverip",
"string",
",",
"pxeservertype",
"string",
",",
"tftpdir",
"string",
",",
"url",
"string",
",",
"username",
"string",
")",
"*",
"AddBaremetalPxePingServerParams",
"{",
"p",
":=",
"&",
"AddBaremetalPxePingServerParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"password",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"physicalnetworkid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"pingdir",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"pingstorageserverip",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"pxeservertype",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"tftpdir",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"url",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"username",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddBaremetalPxePingServerParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddBaremetalPxePingServerParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L427-L439
|
145,892 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
AddBaremetalPxePingServer
|
func (s *BaremetalService) AddBaremetalPxePingServer(p *AddBaremetalPxePingServerParams) (*AddBaremetalPxePingServerResponse, error) {
resp, err := s.cs.newRequest("addBaremetalPxePingServer", p.toURLValues())
if err != nil {
return nil, err
}
var r AddBaremetalPxePingServerResponse
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
}
|
go
|
func (s *BaremetalService) AddBaremetalPxePingServer(p *AddBaremetalPxePingServerParams) (*AddBaremetalPxePingServerResponse, error) {
resp, err := s.cs.newRequest("addBaremetalPxePingServer", p.toURLValues())
if err != nil {
return nil, err
}
var r AddBaremetalPxePingServerResponse
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
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"AddBaremetalPxePingServer",
"(",
"p",
"*",
"AddBaremetalPxePingServerParams",
")",
"(",
"*",
"AddBaremetalPxePingServerResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddBaremetalPxePingServerResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// add a baremetal ping pxe server
|
[
"add",
"a",
"baremetal",
"ping",
"pxe",
"server"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L442-L474
|
145,893 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
NewAddBaremetalRctParams
|
func (s *BaremetalService) NewAddBaremetalRctParams(baremetalrcturl string) *AddBaremetalRctParams {
p := &AddBaremetalRctParams{}
p.p = make(map[string]interface{})
p.p["baremetalrcturl"] = baremetalrcturl
return p
}
|
go
|
func (s *BaremetalService) NewAddBaremetalRctParams(baremetalrcturl string) *AddBaremetalRctParams {
p := &AddBaremetalRctParams{}
p.p = make(map[string]interface{})
p.p["baremetalrcturl"] = baremetalrcturl
return p
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"NewAddBaremetalRctParams",
"(",
"baremetalrcturl",
"string",
")",
"*",
"AddBaremetalRctParams",
"{",
"p",
":=",
"&",
"AddBaremetalRctParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"baremetalrcturl",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddBaremetalRctParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddBaremetalRctParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L508-L513
|
145,894 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
AddBaremetalRct
|
func (s *BaremetalService) AddBaremetalRct(p *AddBaremetalRctParams) (*AddBaremetalRctResponse, error) {
resp, err := s.cs.newRequest("addBaremetalRct", p.toURLValues())
if err != nil {
return nil, err
}
var r AddBaremetalRctResponse
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
}
|
go
|
func (s *BaremetalService) AddBaremetalRct(p *AddBaremetalRctParams) (*AddBaremetalRctResponse, error) {
resp, err := s.cs.newRequest("addBaremetalRct", p.toURLValues())
if err != nil {
return nil, err
}
var r AddBaremetalRctResponse
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
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"AddBaremetalRct",
"(",
"p",
"*",
"AddBaremetalRctParams",
")",
"(",
"*",
"AddBaremetalRctResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"AddBaremetalRctResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
",",
"err",
"=",
"getRawValue",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// adds baremetal rack configuration text
|
[
"adds",
"baremetal",
"rack",
"configuration",
"text"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L516-L548
|
145,895 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
NewDeleteBaremetalRctParams
|
func (s *BaremetalService) NewDeleteBaremetalRctParams(id string) *DeleteBaremetalRctParams {
p := &DeleteBaremetalRctParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *BaremetalService) NewDeleteBaremetalRctParams(id string) *DeleteBaremetalRctParams {
p := &DeleteBaremetalRctParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"NewDeleteBaremetalRctParams",
"(",
"id",
"string",
")",
"*",
"DeleteBaremetalRctParams",
"{",
"p",
":=",
"&",
"DeleteBaremetalRctParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DeleteBaremetalRctParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteBaremetalRctParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L581-L586
|
145,896 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
DeleteBaremetalRct
|
func (s *BaremetalService) DeleteBaremetalRct(p *DeleteBaremetalRctParams) (*DeleteBaremetalRctResponse, error) {
resp, err := s.cs.newRequest("deleteBaremetalRct", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteBaremetalRctResponse
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
}
|
go
|
func (s *BaremetalService) DeleteBaremetalRct(p *DeleteBaremetalRctParams) (*DeleteBaremetalRctResponse, error) {
resp, err := s.cs.newRequest("deleteBaremetalRct", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteBaremetalRctResponse
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
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"DeleteBaremetalRct",
"(",
"p",
"*",
"DeleteBaremetalRctParams",
")",
"(",
"*",
"DeleteBaremetalRctResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeleteBaremetalRctResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"AsyncTimeoutErr",
"{",
"return",
"&",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// deletes baremetal rack configuration text
|
[
"deletes",
"baremetal",
"rack",
"configuration",
"text"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L589-L616
|
145,897 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
NewListBaremetalDhcpParams
|
func (s *BaremetalService) NewListBaremetalDhcpParams(physicalnetworkid string) *ListBaremetalDhcpParams {
p := &ListBaremetalDhcpParams{}
p.p = make(map[string]interface{})
p.p["physicalnetworkid"] = physicalnetworkid
return p
}
|
go
|
func (s *BaremetalService) NewListBaremetalDhcpParams(physicalnetworkid string) *ListBaremetalDhcpParams {
p := &ListBaremetalDhcpParams{}
p.p = make(map[string]interface{})
p.p["physicalnetworkid"] = physicalnetworkid
return p
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"NewListBaremetalDhcpParams",
"(",
"physicalnetworkid",
"string",
")",
"*",
"ListBaremetalDhcpParams",
"{",
"p",
":=",
"&",
"ListBaremetalDhcpParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"physicalnetworkid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListBaremetalDhcpParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListBaremetalDhcpParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L707-L712
|
145,898 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
ListBaremetalDhcp
|
func (s *BaremetalService) ListBaremetalDhcp(p *ListBaremetalDhcpParams) (*ListBaremetalDhcpResponse, error) {
resp, err := s.cs.newRequest("listBaremetalDhcp", p.toURLValues())
if err != nil {
return nil, err
}
var r ListBaremetalDhcpResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *BaremetalService) ListBaremetalDhcp(p *ListBaremetalDhcpParams) (*ListBaremetalDhcpResponse, error) {
resp, err := s.cs.newRequest("listBaremetalDhcp", p.toURLValues())
if err != nil {
return nil, err
}
var r ListBaremetalDhcpResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"ListBaremetalDhcp",
"(",
"p",
"*",
"ListBaremetalDhcpParams",
")",
"(",
"*",
"ListBaremetalDhcpResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListBaremetalDhcpResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// list baremetal dhcp servers
|
[
"list",
"baremetal",
"dhcp",
"servers"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L715-L727
|
145,899 |
xanzy/go-cloudstack
|
cloudstack/BaremetalService.go
|
NewListBaremetalPxeServersParams
|
func (s *BaremetalService) NewListBaremetalPxeServersParams(physicalnetworkid string) *ListBaremetalPxeServersParams {
p := &ListBaremetalPxeServersParams{}
p.p = make(map[string]interface{})
p.p["physicalnetworkid"] = physicalnetworkid
return p
}
|
go
|
func (s *BaremetalService) NewListBaremetalPxeServersParams(physicalnetworkid string) *ListBaremetalPxeServersParams {
p := &ListBaremetalPxeServersParams{}
p.p = make(map[string]interface{})
p.p["physicalnetworkid"] = physicalnetworkid
return p
}
|
[
"func",
"(",
"s",
"*",
"BaremetalService",
")",
"NewListBaremetalPxeServersParams",
"(",
"physicalnetworkid",
"string",
")",
"*",
"ListBaremetalPxeServersParams",
"{",
"p",
":=",
"&",
"ListBaremetalPxeServersParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"physicalnetworkid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListBaremetalPxeServersParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListBaremetalPxeServersParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/BaremetalService.go#L814-L819
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.