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,600 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewCancelHostMaintenanceParams
|
func (s *HostService) NewCancelHostMaintenanceParams(id string) *CancelHostMaintenanceParams {
p := &CancelHostMaintenanceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *HostService) NewCancelHostMaintenanceParams(id string) *CancelHostMaintenanceParams {
p := &CancelHostMaintenanceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewCancelHostMaintenanceParams",
"(",
"id",
"string",
")",
"*",
"CancelHostMaintenanceParams",
"{",
"p",
":=",
"&",
"CancelHostMaintenanceParams",
"{",
"}",
"\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 CancelHostMaintenanceParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CancelHostMaintenanceParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L682-L687
|
145,601 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewDedicateHostParams
|
func (s *HostService) NewDedicateHostParams(domainid string, hostid string) *DedicateHostParams {
p := &DedicateHostParams{}
p.p = make(map[string]interface{})
p.p["domainid"] = domainid
p.p["hostid"] = hostid
return p
}
|
go
|
func (s *HostService) NewDedicateHostParams(domainid string, hostid string) *DedicateHostParams {
p := &DedicateHostParams{}
p.p = make(map[string]interface{})
p.p["domainid"] = domainid
p.p["hostid"] = hostid
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewDedicateHostParams",
"(",
"domainid",
"string",
",",
"hostid",
"string",
")",
"*",
"DedicateHostParams",
"{",
"p",
":=",
"&",
"DedicateHostParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"domainid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"hostid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DedicateHostParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DedicateHostParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L843-L849
|
145,602 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewDeleteHostParams
|
func (s *HostService) NewDeleteHostParams(id string) *DeleteHostParams {
p := &DeleteHostParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *HostService) NewDeleteHostParams(id string) *DeleteHostParams {
p := &DeleteHostParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewDeleteHostParams",
"(",
"id",
"string",
")",
"*",
"DeleteHostParams",
"{",
"p",
":=",
"&",
"DeleteHostParams",
"{",
"}",
"\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 DeleteHostParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteHostParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L945-L950
|
145,603 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewDisableOutOfBandManagementForHostParams
|
func (s *HostService) NewDisableOutOfBandManagementForHostParams(hostid string) *DisableOutOfBandManagementForHostParams {
p := &DisableOutOfBandManagementForHostParams{}
p.p = make(map[string]interface{})
p.p["hostid"] = hostid
return p
}
|
go
|
func (s *HostService) NewDisableOutOfBandManagementForHostParams(hostid string) *DisableOutOfBandManagementForHostParams {
p := &DisableOutOfBandManagementForHostParams{}
p.p = make(map[string]interface{})
p.p["hostid"] = hostid
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewDisableOutOfBandManagementForHostParams",
"(",
"hostid",
"string",
")",
"*",
"DisableOutOfBandManagementForHostParams",
"{",
"p",
":=",
"&",
"DisableOutOfBandManagementForHostParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"hostid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DisableOutOfBandManagementForHostParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DisableOutOfBandManagementForHostParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1016-L1021
|
145,604 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
DisableOutOfBandManagementForHost
|
func (s *HostService) DisableOutOfBandManagementForHost(p *DisableOutOfBandManagementForHostParams) (*DisableOutOfBandManagementForHostResponse, error) {
resp, err := s.cs.newRequest("disableOutOfBandManagementForHost", p.toURLValues())
if err != nil {
return nil, err
}
var r DisableOutOfBandManagementForHostResponse
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 *HostService) DisableOutOfBandManagementForHost(p *DisableOutOfBandManagementForHostParams) (*DisableOutOfBandManagementForHostResponse, error) {
resp, err := s.cs.newRequest("disableOutOfBandManagementForHost", p.toURLValues())
if err != nil {
return nil, err
}
var r DisableOutOfBandManagementForHostResponse
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",
"*",
"HostService",
")",
"DisableOutOfBandManagementForHost",
"(",
"p",
"*",
"DisableOutOfBandManagementForHostParams",
")",
"(",
"*",
"DisableOutOfBandManagementForHostResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DisableOutOfBandManagementForHostResponse",
"\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 host
|
[
"Disables",
"out",
"-",
"of",
"-",
"band",
"management",
"for",
"a",
"host"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1024-L1056
|
145,605 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewEnableOutOfBandManagementForHostParams
|
func (s *HostService) NewEnableOutOfBandManagementForHostParams(hostid string) *EnableOutOfBandManagementForHostParams {
p := &EnableOutOfBandManagementForHostParams{}
p.p = make(map[string]interface{})
p.p["hostid"] = hostid
return p
}
|
go
|
func (s *HostService) NewEnableOutOfBandManagementForHostParams(hostid string) *EnableOutOfBandManagementForHostParams {
p := &EnableOutOfBandManagementForHostParams{}
p.p = make(map[string]interface{})
p.p["hostid"] = hostid
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewEnableOutOfBandManagementForHostParams",
"(",
"hostid",
"string",
")",
"*",
"EnableOutOfBandManagementForHostParams",
"{",
"p",
":=",
"&",
"EnableOutOfBandManagementForHostParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"hostid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new EnableOutOfBandManagementForHostParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"EnableOutOfBandManagementForHostParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1098-L1103
|
145,606 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
EnableOutOfBandManagementForHost
|
func (s *HostService) EnableOutOfBandManagementForHost(p *EnableOutOfBandManagementForHostParams) (*EnableOutOfBandManagementForHostResponse, error) {
resp, err := s.cs.newRequest("enableOutOfBandManagementForHost", p.toURLValues())
if err != nil {
return nil, err
}
var r EnableOutOfBandManagementForHostResponse
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 *HostService) EnableOutOfBandManagementForHost(p *EnableOutOfBandManagementForHostParams) (*EnableOutOfBandManagementForHostResponse, error) {
resp, err := s.cs.newRequest("enableOutOfBandManagementForHost", p.toURLValues())
if err != nil {
return nil, err
}
var r EnableOutOfBandManagementForHostResponse
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",
"*",
"HostService",
")",
"EnableOutOfBandManagementForHost",
"(",
"p",
"*",
"EnableOutOfBandManagementForHostParams",
")",
"(",
"*",
"EnableOutOfBandManagementForHostResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"EnableOutOfBandManagementForHostResponse",
"\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 host
|
[
"Enables",
"out",
"-",
"of",
"-",
"band",
"management",
"for",
"a",
"host"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1106-L1138
|
145,607 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewFindHostsForMigrationParams
|
func (s *HostService) NewFindHostsForMigrationParams(virtualmachineid string) *FindHostsForMigrationParams {
p := &FindHostsForMigrationParams{}
p.p = make(map[string]interface{})
p.p["virtualmachineid"] = virtualmachineid
return p
}
|
go
|
func (s *HostService) NewFindHostsForMigrationParams(virtualmachineid string) *FindHostsForMigrationParams {
p := &FindHostsForMigrationParams{}
p.p = make(map[string]interface{})
p.p["virtualmachineid"] = virtualmachineid
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewFindHostsForMigrationParams",
"(",
"virtualmachineid",
"string",
")",
"*",
"FindHostsForMigrationParams",
"{",
"p",
":=",
"&",
"FindHostsForMigrationParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"virtualmachineid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new FindHostsForMigrationParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"FindHostsForMigrationParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1215-L1220
|
145,608 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewListDedicatedHostsParams
|
func (s *HostService) NewListDedicatedHostsParams() *ListDedicatedHostsParams {
p := &ListDedicatedHostsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *HostService) NewListDedicatedHostsParams() *ListDedicatedHostsParams {
p := &ListDedicatedHostsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewListDedicatedHostsParams",
"(",
")",
"*",
"ListDedicatedHostsParams",
"{",
"p",
":=",
"&",
"ListDedicatedHostsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListDedicatedHostsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListDedicatedHostsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1378-L1382
|
145,609 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewListHostTagsParams
|
func (s *HostService) NewListHostTagsParams() *ListHostTagsParams {
p := &ListHostTagsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *HostService) NewListHostTagsParams() *ListHostTagsParams {
p := &ListHostTagsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewListHostTagsParams",
"(",
")",
"*",
"ListHostTagsParams",
"{",
"p",
":=",
"&",
"ListHostTagsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListHostTagsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListHostTagsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1462-L1466
|
145,610 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewListHostsParams
|
func (s *HostService) NewListHostsParams() *ListHostsParams {
p := &ListHostsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *HostService) NewListHostsParams() *ListHostsParams {
p := &ListHostsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewListHostsParams",
"(",
")",
"*",
"ListHostsParams",
"{",
"p",
":=",
"&",
"ListHostsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListHostsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListHostsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1736-L1740
|
145,611 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewPrepareHostForMaintenanceParams
|
func (s *HostService) NewPrepareHostForMaintenanceParams(id string) *PrepareHostForMaintenanceParams {
p := &PrepareHostForMaintenanceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *HostService) NewPrepareHostForMaintenanceParams(id string) *PrepareHostForMaintenanceParams {
p := &PrepareHostForMaintenanceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewPrepareHostForMaintenanceParams",
"(",
"id",
"string",
")",
"*",
"PrepareHostForMaintenanceParams",
"{",
"p",
":=",
"&",
"PrepareHostForMaintenanceParams",
"{",
"}",
"\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 PrepareHostForMaintenanceParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"PrepareHostForMaintenanceParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L1941-L1946
|
145,612 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewReconnectHostParams
|
func (s *HostService) NewReconnectHostParams(id string) *ReconnectHostParams {
p := &ReconnectHostParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *HostService) NewReconnectHostParams(id string) *ReconnectHostParams {
p := &ReconnectHostParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewReconnectHostParams",
"(",
"id",
"string",
")",
"*",
"ReconnectHostParams",
"{",
"p",
":=",
"&",
"ReconnectHostParams",
"{",
"}",
"\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 ReconnectHostParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ReconnectHostParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L2080-L2085
|
145,613 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewReleaseDedicatedHostParams
|
func (s *HostService) NewReleaseDedicatedHostParams(hostid string) *ReleaseDedicatedHostParams {
p := &ReleaseDedicatedHostParams{}
p.p = make(map[string]interface{})
p.p["hostid"] = hostid
return p
}
|
go
|
func (s *HostService) NewReleaseDedicatedHostParams(hostid string) *ReleaseDedicatedHostParams {
p := &ReleaseDedicatedHostParams{}
p.p = make(map[string]interface{})
p.p["hostid"] = hostid
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewReleaseDedicatedHostParams",
"(",
"hostid",
"string",
")",
"*",
"ReleaseDedicatedHostParams",
"{",
"p",
":=",
"&",
"ReleaseDedicatedHostParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"hostid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ReleaseDedicatedHostParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ReleaseDedicatedHostParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L2219-L2224
|
145,614 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewReleaseHostReservationParams
|
func (s *HostService) NewReleaseHostReservationParams(id string) *ReleaseHostReservationParams {
p := &ReleaseHostReservationParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *HostService) NewReleaseHostReservationParams(id string) *ReleaseHostReservationParams {
p := &ReleaseHostReservationParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewReleaseHostReservationParams",
"(",
"id",
"string",
")",
"*",
"ReleaseHostReservationParams",
"{",
"p",
":=",
"&",
"ReleaseHostReservationParams",
"{",
"}",
"\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 ReleaseHostReservationParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ReleaseHostReservationParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L2287-L2292
|
145,615 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewUpdateHostParams
|
func (s *HostService) NewUpdateHostParams(id string) *UpdateHostParams {
p := &UpdateHostParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *HostService) NewUpdateHostParams(id string) *UpdateHostParams {
p := &UpdateHostParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewUpdateHostParams",
"(",
"id",
"string",
")",
"*",
"UpdateHostParams",
"{",
"p",
":=",
"&",
"UpdateHostParams",
"{",
"}",
"\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 UpdateHostParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateHostParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L2411-L2416
|
145,616 |
xanzy/go-cloudstack
|
cloudstack/HostService.go
|
NewUpdateHostPasswordParams
|
func (s *HostService) NewUpdateHostPasswordParams(password string, username string) *UpdateHostPasswordParams {
p := &UpdateHostPasswordParams{}
p.p = make(map[string]interface{})
p.p["password"] = password
p.p["username"] = username
return p
}
|
go
|
func (s *HostService) NewUpdateHostPasswordParams(password string, username string) *UpdateHostPasswordParams {
p := &UpdateHostPasswordParams{}
p.p = make(map[string]interface{})
p.p["password"] = password
p.p["username"] = username
return p
}
|
[
"func",
"(",
"s",
"*",
"HostService",
")",
"NewUpdateHostPasswordParams",
"(",
"password",
"string",
",",
"username",
"string",
")",
"*",
"UpdateHostPasswordParams",
"{",
"p",
":=",
"&",
"UpdateHostPasswordParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"password",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"username",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateHostPasswordParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateHostPasswordParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/HostService.go#L2574-L2580
|
145,617 |
xanzy/go-cloudstack
|
cloudstack/NetworkDeviceService.go
|
NewAddNetworkDeviceParams
|
func (s *NetworkDeviceService) NewAddNetworkDeviceParams() *AddNetworkDeviceParams {
p := &AddNetworkDeviceParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *NetworkDeviceService) NewAddNetworkDeviceParams() *AddNetworkDeviceParams {
p := &AddNetworkDeviceParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"NetworkDeviceService",
")",
"NewAddNetworkDeviceParams",
"(",
")",
"*",
"AddNetworkDeviceParams",
"{",
"p",
":=",
"&",
"AddNetworkDeviceParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AddNetworkDeviceParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AddNetworkDeviceParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/NetworkDeviceService.go#L67-L71
|
145,618 |
xanzy/go-cloudstack
|
cloudstack/NetworkDeviceService.go
|
NewDeleteNetworkDeviceParams
|
func (s *NetworkDeviceService) NewDeleteNetworkDeviceParams(id string) *DeleteNetworkDeviceParams {
p := &DeleteNetworkDeviceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *NetworkDeviceService) NewDeleteNetworkDeviceParams(id string) *DeleteNetworkDeviceParams {
p := &DeleteNetworkDeviceParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"NetworkDeviceService",
")",
"NewDeleteNetworkDeviceParams",
"(",
"id",
"string",
")",
"*",
"DeleteNetworkDeviceParams",
"{",
"p",
":=",
"&",
"DeleteNetworkDeviceParams",
"{",
"}",
"\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 DeleteNetworkDeviceParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteNetworkDeviceParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/NetworkDeviceService.go#L117-L122
|
145,619 |
xanzy/go-cloudstack
|
cloudstack/NetworkDeviceService.go
|
DeleteNetworkDevice
|
func (s *NetworkDeviceService) DeleteNetworkDevice(p *DeleteNetworkDeviceParams) (*DeleteNetworkDeviceResponse, error) {
resp, err := s.cs.newRequest("deleteNetworkDevice", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteNetworkDeviceResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *NetworkDeviceService) DeleteNetworkDevice(p *DeleteNetworkDeviceParams) (*DeleteNetworkDeviceResponse, error) {
resp, err := s.cs.newRequest("deleteNetworkDevice", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteNetworkDeviceResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"NetworkDeviceService",
")",
"DeleteNetworkDevice",
"(",
"p",
"*",
"DeleteNetworkDeviceParams",
")",
"(",
"*",
"DeleteNetworkDeviceResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeleteNetworkDeviceResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Deletes network device.
|
[
"Deletes",
"network",
"device",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/NetworkDeviceService.go#L125-L137
|
145,620 |
xanzy/go-cloudstack
|
cloudstack/NetworkDeviceService.go
|
NewListNetworkDeviceParams
|
func (s *NetworkDeviceService) NewListNetworkDeviceParams() *ListNetworkDeviceParams {
p := &ListNetworkDeviceParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *NetworkDeviceService) NewListNetworkDeviceParams() *ListNetworkDeviceParams {
p := &ListNetworkDeviceParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"NetworkDeviceService",
")",
"NewListNetworkDeviceParams",
"(",
")",
"*",
"ListNetworkDeviceParams",
"{",
"p",
":=",
"&",
"ListNetworkDeviceParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListNetworkDeviceParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListNetworkDeviceParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/NetworkDeviceService.go#L239-L243
|
145,621 |
xanzy/go-cloudstack
|
cloudstack/NetworkDeviceService.go
|
ListNetworkDevice
|
func (s *NetworkDeviceService) ListNetworkDevice(p *ListNetworkDeviceParams) (*ListNetworkDeviceResponse, error) {
resp, err := s.cs.newRequest("listNetworkDevice", p.toURLValues())
if err != nil {
return nil, err
}
var r ListNetworkDeviceResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *NetworkDeviceService) ListNetworkDevice(p *ListNetworkDeviceParams) (*ListNetworkDeviceResponse, error) {
resp, err := s.cs.newRequest("listNetworkDevice", p.toURLValues())
if err != nil {
return nil, err
}
var r ListNetworkDeviceResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"NetworkDeviceService",
")",
"ListNetworkDevice",
"(",
"p",
"*",
"ListNetworkDeviceParams",
")",
"(",
"*",
"ListNetworkDeviceResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListNetworkDeviceResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// List network devices
|
[
"List",
"network",
"devices"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/NetworkDeviceService.go#L246-L258
|
145,622 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewCreatePrivateGatewayParams
|
func (s *VPCService) NewCreatePrivateGatewayParams(gateway string, ipaddress string, netmask string, vlan string, vpcid string) *CreatePrivateGatewayParams {
p := &CreatePrivateGatewayParams{}
p.p = make(map[string]interface{})
p.p["gateway"] = gateway
p.p["ipaddress"] = ipaddress
p.p["netmask"] = netmask
p.p["vlan"] = vlan
p.p["vpcid"] = vpcid
return p
}
|
go
|
func (s *VPCService) NewCreatePrivateGatewayParams(gateway string, ipaddress string, netmask string, vlan string, vpcid string) *CreatePrivateGatewayParams {
p := &CreatePrivateGatewayParams{}
p.p = make(map[string]interface{})
p.p["gateway"] = gateway
p.p["ipaddress"] = ipaddress
p.p["netmask"] = netmask
p.p["vlan"] = vlan
p.p["vpcid"] = vpcid
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewCreatePrivateGatewayParams",
"(",
"gateway",
"string",
",",
"ipaddress",
"string",
",",
"netmask",
"string",
",",
"vlan",
"string",
",",
"vpcid",
"string",
")",
"*",
"CreatePrivateGatewayParams",
"{",
"p",
":=",
"&",
"CreatePrivateGatewayParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"gateway",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"ipaddress",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"netmask",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"vlan",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"vpcid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CreatePrivateGatewayParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CreatePrivateGatewayParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L141-L150
|
145,623 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
CreatePrivateGateway
|
func (s *VPCService) CreatePrivateGateway(p *CreatePrivateGatewayParams) (*CreatePrivateGatewayResponse, error) {
resp, err := s.cs.newRequest("createPrivateGateway", p.toURLValues())
if err != nil {
return nil, err
}
var r CreatePrivateGatewayResponse
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 *VPCService) CreatePrivateGateway(p *CreatePrivateGatewayParams) (*CreatePrivateGatewayResponse, error) {
resp, err := s.cs.newRequest("createPrivateGateway", p.toURLValues())
if err != nil {
return nil, err
}
var r CreatePrivateGatewayResponse
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",
"*",
"VPCService",
")",
"CreatePrivateGateway",
"(",
"p",
"*",
"CreatePrivateGatewayParams",
")",
"(",
"*",
"CreatePrivateGatewayResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"CreatePrivateGatewayResponse",
"\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",
"}"
] |
// Creates a private gateway
|
[
"Creates",
"a",
"private",
"gateway"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L153-L185
|
145,624 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewCreateStaticRouteParams
|
func (s *VPCService) NewCreateStaticRouteParams(cidr string, gatewayid string) *CreateStaticRouteParams {
p := &CreateStaticRouteParams{}
p.p = make(map[string]interface{})
p.p["cidr"] = cidr
p.p["gatewayid"] = gatewayid
return p
}
|
go
|
func (s *VPCService) NewCreateStaticRouteParams(cidr string, gatewayid string) *CreateStaticRouteParams {
p := &CreateStaticRouteParams{}
p.p = make(map[string]interface{})
p.p["cidr"] = cidr
p.p["gatewayid"] = gatewayid
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewCreateStaticRouteParams",
"(",
"cidr",
"string",
",",
"gatewayid",
"string",
")",
"*",
"CreateStaticRouteParams",
"{",
"p",
":=",
"&",
"CreateStaticRouteParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"cidr",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"gatewayid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CreateStaticRouteParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CreateStaticRouteParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L244-L250
|
145,625 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
CreateStaticRoute
|
func (s *VPCService) CreateStaticRoute(p *CreateStaticRouteParams) (*CreateStaticRouteResponse, error) {
resp, err := s.cs.newRequest("createStaticRoute", p.toURLValues())
if err != nil {
return nil, err
}
var r CreateStaticRouteResponse
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 *VPCService) CreateStaticRoute(p *CreateStaticRouteParams) (*CreateStaticRouteResponse, error) {
resp, err := s.cs.newRequest("createStaticRoute", p.toURLValues())
if err != nil {
return nil, err
}
var r CreateStaticRouteResponse
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",
"*",
"VPCService",
")",
"CreateStaticRoute",
"(",
"p",
"*",
"CreateStaticRouteParams",
")",
"(",
"*",
"CreateStaticRouteResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"CreateStaticRouteResponse",
"\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",
"}"
] |
// Creates a static route
|
[
"Creates",
"a",
"static",
"route"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L253-L285
|
145,626 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewCreateVPCParams
|
func (s *VPCService) NewCreateVPCParams(cidr string, displaytext string, name string, vpcofferingid string, zoneid string) *CreateVPCParams {
p := &CreateVPCParams{}
p.p = make(map[string]interface{})
p.p["cidr"] = cidr
p.p["displaytext"] = displaytext
p.p["name"] = name
p.p["vpcofferingid"] = vpcofferingid
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *VPCService) NewCreateVPCParams(cidr string, displaytext string, name string, vpcofferingid string, zoneid string) *CreateVPCParams {
p := &CreateVPCParams{}
p.p = make(map[string]interface{})
p.p["cidr"] = cidr
p.p["displaytext"] = displaytext
p.p["name"] = name
p.p["vpcofferingid"] = vpcofferingid
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewCreateVPCParams",
"(",
"cidr",
"string",
",",
"displaytext",
"string",
",",
"name",
"string",
",",
"vpcofferingid",
"string",
",",
"zoneid",
"string",
")",
"*",
"CreateVPCParams",
"{",
"p",
":=",
"&",
"CreateVPCParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"cidr",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"displaytext",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"vpcofferingid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CreateVPCParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CreateVPCParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L439-L448
|
145,627 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
CreateVPC
|
func (s *VPCService) CreateVPC(p *CreateVPCParams) (*CreateVPCResponse, error) {
resp, err := s.cs.newRequest("createVPC", p.toURLValues())
if err != nil {
return nil, err
}
var r CreateVPCResponse
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 *VPCService) CreateVPC(p *CreateVPCParams) (*CreateVPCResponse, error) {
resp, err := s.cs.newRequest("createVPC", p.toURLValues())
if err != nil {
return nil, err
}
var r CreateVPCResponse
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",
"*",
"VPCService",
")",
"CreateVPC",
"(",
"p",
"*",
"CreateVPCParams",
")",
"(",
"*",
"CreateVPCResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"CreateVPCResponse",
"\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",
"}"
] |
// Creates a VPC
|
[
"Creates",
"a",
"VPC"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L451-L483
|
145,628 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewCreateVPCOfferingParams
|
func (s *VPCService) NewCreateVPCOfferingParams(displaytext string, name string, supportedservices []string) *CreateVPCOfferingParams {
p := &CreateVPCOfferingParams{}
p.p = make(map[string]interface{})
p.p["displaytext"] = displaytext
p.p["name"] = name
p.p["supportedservices"] = supportedservices
return p
}
|
go
|
func (s *VPCService) NewCreateVPCOfferingParams(displaytext string, name string, supportedservices []string) *CreateVPCOfferingParams {
p := &CreateVPCOfferingParams{}
p.p = make(map[string]interface{})
p.p["displaytext"] = displaytext
p.p["name"] = name
p.p["supportedservices"] = supportedservices
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewCreateVPCOfferingParams",
"(",
"displaytext",
"string",
",",
"name",
"string",
",",
"supportedservices",
"[",
"]",
"string",
")",
"*",
"CreateVPCOfferingParams",
"{",
"p",
":=",
"&",
"CreateVPCOfferingParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"displaytext",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"supportedservices",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CreateVPCOfferingParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CreateVPCOfferingParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L700-L707
|
145,629 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
CreateVPCOffering
|
func (s *VPCService) CreateVPCOffering(p *CreateVPCOfferingParams) (*CreateVPCOfferingResponse, error) {
resp, err := s.cs.newRequest("createVPCOffering", p.toURLValues())
if err != nil {
return nil, err
}
var r CreateVPCOfferingResponse
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 *VPCService) CreateVPCOffering(p *CreateVPCOfferingParams) (*CreateVPCOfferingResponse, error) {
resp, err := s.cs.newRequest("createVPCOffering", p.toURLValues())
if err != nil {
return nil, err
}
var r CreateVPCOfferingResponse
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",
"*",
"VPCService",
")",
"CreateVPCOffering",
"(",
"p",
"*",
"CreateVPCOfferingParams",
")",
"(",
"*",
"CreateVPCOfferingResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"CreateVPCOfferingResponse",
"\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",
"}"
] |
// Creates VPC offering
|
[
"Creates",
"VPC",
"offering"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L710-L742
|
145,630 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewDeletePrivateGatewayParams
|
func (s *VPCService) NewDeletePrivateGatewayParams(id string) *DeletePrivateGatewayParams {
p := &DeletePrivateGatewayParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VPCService) NewDeletePrivateGatewayParams(id string) *DeletePrivateGatewayParams {
p := &DeletePrivateGatewayParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewDeletePrivateGatewayParams",
"(",
"id",
"string",
")",
"*",
"DeletePrivateGatewayParams",
"{",
"p",
":=",
"&",
"DeletePrivateGatewayParams",
"{",
"}",
"\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 DeletePrivateGatewayParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeletePrivateGatewayParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L804-L809
|
145,631 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
DeletePrivateGateway
|
func (s *VPCService) DeletePrivateGateway(p *DeletePrivateGatewayParams) (*DeletePrivateGatewayResponse, error) {
resp, err := s.cs.newRequest("deletePrivateGateway", p.toURLValues())
if err != nil {
return nil, err
}
var r DeletePrivateGatewayResponse
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 *VPCService) DeletePrivateGateway(p *DeletePrivateGatewayParams) (*DeletePrivateGatewayResponse, error) {
resp, err := s.cs.newRequest("deletePrivateGateway", p.toURLValues())
if err != nil {
return nil, err
}
var r DeletePrivateGatewayResponse
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",
"*",
"VPCService",
")",
"DeletePrivateGateway",
"(",
"p",
"*",
"DeletePrivateGatewayParams",
")",
"(",
"*",
"DeletePrivateGatewayResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeletePrivateGatewayResponse",
"\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 a Private gateway
|
[
"Deletes",
"a",
"Private",
"gateway"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L812-L839
|
145,632 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewDeleteStaticRouteParams
|
func (s *VPCService) NewDeleteStaticRouteParams(id string) *DeleteStaticRouteParams {
p := &DeleteStaticRouteParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VPCService) NewDeleteStaticRouteParams(id string) *DeleteStaticRouteParams {
p := &DeleteStaticRouteParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewDeleteStaticRouteParams",
"(",
"id",
"string",
")",
"*",
"DeleteStaticRouteParams",
"{",
"p",
":=",
"&",
"DeleteStaticRouteParams",
"{",
"}",
"\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 DeleteStaticRouteParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteStaticRouteParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L872-L877
|
145,633 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
DeleteStaticRoute
|
func (s *VPCService) DeleteStaticRoute(p *DeleteStaticRouteParams) (*DeleteStaticRouteResponse, error) {
resp, err := s.cs.newRequest("deleteStaticRoute", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteStaticRouteResponse
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 *VPCService) DeleteStaticRoute(p *DeleteStaticRouteParams) (*DeleteStaticRouteResponse, error) {
resp, err := s.cs.newRequest("deleteStaticRoute", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteStaticRouteResponse
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",
"*",
"VPCService",
")",
"DeleteStaticRoute",
"(",
"p",
"*",
"DeleteStaticRouteParams",
")",
"(",
"*",
"DeleteStaticRouteResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeleteStaticRouteResponse",
"\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 a static route
|
[
"Deletes",
"a",
"static",
"route"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L880-L907
|
145,634 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewDeleteVPCParams
|
func (s *VPCService) NewDeleteVPCParams(id string) *DeleteVPCParams {
p := &DeleteVPCParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VPCService) NewDeleteVPCParams(id string) *DeleteVPCParams {
p := &DeleteVPCParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewDeleteVPCParams",
"(",
"id",
"string",
")",
"*",
"DeleteVPCParams",
"{",
"p",
":=",
"&",
"DeleteVPCParams",
"{",
"}",
"\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 DeleteVPCParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteVPCParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L940-L945
|
145,635 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
DeleteVPC
|
func (s *VPCService) DeleteVPC(p *DeleteVPCParams) (*DeleteVPCResponse, error) {
resp, err := s.cs.newRequest("deleteVPC", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteVPCResponse
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 *VPCService) DeleteVPC(p *DeleteVPCParams) (*DeleteVPCResponse, error) {
resp, err := s.cs.newRequest("deleteVPC", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteVPCResponse
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",
"*",
"VPCService",
")",
"DeleteVPC",
"(",
"p",
"*",
"DeleteVPCParams",
")",
"(",
"*",
"DeleteVPCResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeleteVPCResponse",
"\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 a VPC
|
[
"Deletes",
"a",
"VPC"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L948-L975
|
145,636 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewDeleteVPCOfferingParams
|
func (s *VPCService) NewDeleteVPCOfferingParams(id string) *DeleteVPCOfferingParams {
p := &DeleteVPCOfferingParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VPCService) NewDeleteVPCOfferingParams(id string) *DeleteVPCOfferingParams {
p := &DeleteVPCOfferingParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewDeleteVPCOfferingParams",
"(",
"id",
"string",
")",
"*",
"DeleteVPCOfferingParams",
"{",
"p",
":=",
"&",
"DeleteVPCOfferingParams",
"{",
"}",
"\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 DeleteVPCOfferingParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteVPCOfferingParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L1008-L1013
|
145,637 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
DeleteVPCOffering
|
func (s *VPCService) DeleteVPCOffering(p *DeleteVPCOfferingParams) (*DeleteVPCOfferingResponse, error) {
resp, err := s.cs.newRequest("deleteVPCOffering", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteVPCOfferingResponse
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 *VPCService) DeleteVPCOffering(p *DeleteVPCOfferingParams) (*DeleteVPCOfferingResponse, error) {
resp, err := s.cs.newRequest("deleteVPCOffering", p.toURLValues())
if err != nil {
return nil, err
}
var r DeleteVPCOfferingResponse
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",
"*",
"VPCService",
")",
"DeleteVPCOffering",
"(",
"p",
"*",
"DeleteVPCOfferingParams",
")",
"(",
"*",
"DeleteVPCOfferingResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DeleteVPCOfferingResponse",
"\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 VPC offering
|
[
"Deletes",
"VPC",
"offering"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L1016-L1043
|
145,638 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewListPrivateGatewaysParams
|
func (s *VPCService) NewListPrivateGatewaysParams() *ListPrivateGatewaysParams {
p := &ListPrivateGatewaysParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *VPCService) NewListPrivateGatewaysParams() *ListPrivateGatewaysParams {
p := &ListPrivateGatewaysParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewListPrivateGatewaysParams",
"(",
")",
"*",
"ListPrivateGatewaysParams",
"{",
"p",
":=",
"&",
"ListPrivateGatewaysParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListPrivateGatewaysParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListPrivateGatewaysParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L1212-L1216
|
145,639 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
ListPrivateGateways
|
func (s *VPCService) ListPrivateGateways(p *ListPrivateGatewaysParams) (*ListPrivateGatewaysResponse, error) {
resp, err := s.cs.newRequest("listPrivateGateways", p.toURLValues())
if err != nil {
return nil, err
}
var r ListPrivateGatewaysResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *VPCService) ListPrivateGateways(p *ListPrivateGatewaysParams) (*ListPrivateGatewaysResponse, error) {
resp, err := s.cs.newRequest("listPrivateGateways", p.toURLValues())
if err != nil {
return nil, err
}
var r ListPrivateGatewaysResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"ListPrivateGateways",
"(",
"p",
"*",
"ListPrivateGatewaysParams",
")",
"(",
"*",
"ListPrivateGatewaysResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListPrivateGatewaysResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// List private gateways
|
[
"List",
"private",
"gateways"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L1252-L1264
|
145,640 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewListStaticRoutesParams
|
func (s *VPCService) NewListStaticRoutesParams() *ListStaticRoutesParams {
p := &ListStaticRoutesParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *VPCService) NewListStaticRoutesParams() *ListStaticRoutesParams {
p := &ListStaticRoutesParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewListStaticRoutesParams",
"(",
")",
"*",
"ListStaticRoutesParams",
"{",
"p",
":=",
"&",
"ListStaticRoutesParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListStaticRoutesParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListStaticRoutesParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L1446-L1450
|
145,641 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
ListStaticRoutes
|
func (s *VPCService) ListStaticRoutes(p *ListStaticRoutesParams) (*ListStaticRoutesResponse, error) {
resp, err := s.cs.newRequest("listStaticRoutes", p.toURLValues())
if err != nil {
return nil, err
}
var r ListStaticRoutesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *VPCService) ListStaticRoutes(p *ListStaticRoutesParams) (*ListStaticRoutesResponse, error) {
resp, err := s.cs.newRequest("listStaticRoutes", p.toURLValues())
if err != nil {
return nil, err
}
var r ListStaticRoutesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"ListStaticRoutes",
"(",
"p",
"*",
"ListStaticRoutesParams",
")",
"(",
"*",
"ListStaticRoutesResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListStaticRoutesResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Lists all static routes
|
[
"Lists",
"all",
"static",
"routes"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L1486-L1498
|
145,642 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewListVPCOfferingsParams
|
func (s *VPCService) NewListVPCOfferingsParams() *ListVPCOfferingsParams {
p := &ListVPCOfferingsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *VPCService) NewListVPCOfferingsParams() *ListVPCOfferingsParams {
p := &ListVPCOfferingsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewListVPCOfferingsParams",
"(",
")",
"*",
"ListVPCOfferingsParams",
"{",
"p",
":=",
"&",
"ListVPCOfferingsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListVPCOfferingsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListVPCOfferingsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L1636-L1640
|
145,643 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
ListVPCOfferings
|
func (s *VPCService) ListVPCOfferings(p *ListVPCOfferingsParams) (*ListVPCOfferingsResponse, error) {
resp, err := s.cs.newRequest("listVPCOfferings", p.toURLValues())
if err != nil {
return nil, err
}
var r ListVPCOfferingsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *VPCService) ListVPCOfferings(p *ListVPCOfferingsParams) (*ListVPCOfferingsResponse, error) {
resp, err := s.cs.newRequest("listVPCOfferings", p.toURLValues())
if err != nil {
return nil, err
}
var r ListVPCOfferingsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"ListVPCOfferings",
"(",
"p",
"*",
"ListVPCOfferingsParams",
")",
"(",
"*",
"ListVPCOfferingsResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListVPCOfferingsResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Lists VPC offerings
|
[
"Lists",
"VPC",
"offerings"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L1726-L1738
|
145,644 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewListVPCsParams
|
func (s *VPCService) NewListVPCsParams() *ListVPCsParams {
p := &ListVPCsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *VPCService) NewListVPCsParams() *ListVPCsParams {
p := &ListVPCsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewListVPCsParams",
"(",
")",
"*",
"ListVPCsParams",
"{",
"p",
":=",
"&",
"ListVPCsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListVPCsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListVPCsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L2014-L2018
|
145,645 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewRestartVPCParams
|
func (s *VPCService) NewRestartVPCParams(id string) *RestartVPCParams {
p := &RestartVPCParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VPCService) NewRestartVPCParams(id string) *RestartVPCParams {
p := &RestartVPCParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewRestartVPCParams",
"(",
"id",
"string",
")",
"*",
"RestartVPCParams",
"{",
"p",
":=",
"&",
"RestartVPCParams",
"{",
"}",
"\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 RestartVPCParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"RestartVPCParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L2295-L2300
|
145,646 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
RestartVPC
|
func (s *VPCService) RestartVPC(p *RestartVPCParams) (*RestartVPCResponse, error) {
resp, err := s.cs.newRequest("restartVPC", p.toURLValues())
if err != nil {
return nil, err
}
var r RestartVPCResponse
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 *VPCService) RestartVPC(p *RestartVPCParams) (*RestartVPCResponse, error) {
resp, err := s.cs.newRequest("restartVPC", p.toURLValues())
if err != nil {
return nil, err
}
var r RestartVPCResponse
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",
"*",
"VPCService",
")",
"RestartVPC",
"(",
"p",
"*",
"RestartVPCParams",
")",
"(",
"*",
"RestartVPCResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"RestartVPCResponse",
"\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",
"}"
] |
// Restarts a VPC
|
[
"Restarts",
"a",
"VPC"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L2303-L2335
|
145,647 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewUpdateVPCParams
|
func (s *VPCService) NewUpdateVPCParams(id string) *UpdateVPCParams {
p := &UpdateVPCParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VPCService) NewUpdateVPCParams(id string) *UpdateVPCParams {
p := &UpdateVPCParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewUpdateVPCParams",
"(",
"id",
"string",
")",
"*",
"UpdateVPCParams",
"{",
"p",
":=",
"&",
"UpdateVPCParams",
"{",
"}",
"\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 UpdateVPCParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateVPCParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L2531-L2536
|
145,648 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
UpdateVPC
|
func (s *VPCService) UpdateVPC(p *UpdateVPCParams) (*UpdateVPCResponse, error) {
resp, err := s.cs.newRequest("updateVPC", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateVPCResponse
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 *VPCService) UpdateVPC(p *UpdateVPCParams) (*UpdateVPCResponse, error) {
resp, err := s.cs.newRequest("updateVPC", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateVPCResponse
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",
"*",
"VPCService",
")",
"UpdateVPC",
"(",
"p",
"*",
"UpdateVPCParams",
")",
"(",
"*",
"UpdateVPCResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"UpdateVPCResponse",
"\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 VPC
|
[
"Updates",
"a",
"VPC"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L2539-L2571
|
145,649 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
NewUpdateVPCOfferingParams
|
func (s *VPCService) NewUpdateVPCOfferingParams(id string) *UpdateVPCOfferingParams {
p := &UpdateVPCOfferingParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VPCService) NewUpdateVPCOfferingParams(id string) *UpdateVPCOfferingParams {
p := &UpdateVPCOfferingParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VPCService",
")",
"NewUpdateVPCOfferingParams",
"(",
"id",
"string",
")",
"*",
"UpdateVPCOfferingParams",
"{",
"p",
":=",
"&",
"UpdateVPCOfferingParams",
"{",
"}",
"\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 UpdateVPCOfferingParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateVPCOfferingParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L2755-L2760
|
145,650 |
xanzy/go-cloudstack
|
cloudstack/VPCService.go
|
UpdateVPCOffering
|
func (s *VPCService) UpdateVPCOffering(p *UpdateVPCOfferingParams) (*UpdateVPCOfferingResponse, error) {
resp, err := s.cs.newRequest("updateVPCOffering", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateVPCOfferingResponse
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 *VPCService) UpdateVPCOffering(p *UpdateVPCOfferingParams) (*UpdateVPCOfferingResponse, error) {
resp, err := s.cs.newRequest("updateVPCOffering", p.toURLValues())
if err != nil {
return nil, err
}
var r UpdateVPCOfferingResponse
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",
"*",
"VPCService",
")",
"UpdateVPCOffering",
"(",
"p",
"*",
"UpdateVPCOfferingParams",
")",
"(",
"*",
"UpdateVPCOfferingResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"UpdateVPCOfferingResponse",
"\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 VPC offering
|
[
"Updates",
"VPC",
"offering"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VPCService.go#L2763-L2795
|
145,651 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewCreateZoneParams
|
func (s *ZoneService) NewCreateZoneParams(dns1 string, internaldns1 string, name string, networktype string) *CreateZoneParams {
p := &CreateZoneParams{}
p.p = make(map[string]interface{})
p.p["dns1"] = dns1
p.p["internaldns1"] = internaldns1
p.p["name"] = name
p.p["networktype"] = networktype
return p
}
|
go
|
func (s *ZoneService) NewCreateZoneParams(dns1 string, internaldns1 string, name string, networktype string) *CreateZoneParams {
p := &CreateZoneParams{}
p.p = make(map[string]interface{})
p.p["dns1"] = dns1
p.p["internaldns1"] = internaldns1
p.p["name"] = name
p.p["networktype"] = networktype
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewCreateZoneParams",
"(",
"dns1",
"string",
",",
"internaldns1",
"string",
",",
"name",
"string",
",",
"networktype",
"string",
")",
"*",
"CreateZoneParams",
"{",
"p",
":=",
"&",
"CreateZoneParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"dns1",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"internaldns1",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"networktype",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CreateZoneParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CreateZoneParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L197-L205
|
145,652 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewDedicateZoneParams
|
func (s *ZoneService) NewDedicateZoneParams(domainid string, zoneid string) *DedicateZoneParams {
p := &DedicateZoneParams{}
p.p = make(map[string]interface{})
p.p["domainid"] = domainid
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *ZoneService) NewDedicateZoneParams(domainid string, zoneid string) *DedicateZoneParams {
p := &DedicateZoneParams{}
p.p = make(map[string]interface{})
p.p["domainid"] = domainid
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewDedicateZoneParams",
"(",
"domainid",
"string",
",",
"zoneid",
"string",
")",
"*",
"DedicateZoneParams",
"{",
"p",
":=",
"&",
"DedicateZoneParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"domainid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DedicateZoneParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DedicateZoneParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L310-L316
|
145,653 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
DedicateZone
|
func (s *ZoneService) DedicateZone(p *DedicateZoneParams) (*DedicateZoneResponse, error) {
resp, err := s.cs.newRequest("dedicateZone", p.toURLValues())
if err != nil {
return nil, err
}
var r DedicateZoneResponse
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 *ZoneService) DedicateZone(p *DedicateZoneParams) (*DedicateZoneResponse, error) {
resp, err := s.cs.newRequest("dedicateZone", p.toURLValues())
if err != nil {
return nil, err
}
var r DedicateZoneResponse
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",
"*",
"ZoneService",
")",
"DedicateZone",
"(",
"p",
"*",
"DedicateZoneParams",
")",
"(",
"*",
"DedicateZoneResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DedicateZoneResponse",
"\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",
"}"
] |
// Dedicates a zones.
|
[
"Dedicates",
"a",
"zones",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L319-L351
|
145,654 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewDeleteZoneParams
|
func (s *ZoneService) NewDeleteZoneParams(id string) *DeleteZoneParams {
p := &DeleteZoneParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *ZoneService) NewDeleteZoneParams(id string) *DeleteZoneParams {
p := &DeleteZoneParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewDeleteZoneParams",
"(",
"id",
"string",
")",
"*",
"DeleteZoneParams",
"{",
"p",
":=",
"&",
"DeleteZoneParams",
"{",
"}",
"\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 DeleteZoneParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteZoneParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L388-L393
|
145,655 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewDisableOutOfBandManagementForZoneParams
|
func (s *ZoneService) NewDisableOutOfBandManagementForZoneParams(zoneid string) *DisableOutOfBandManagementForZoneParams {
p := &DisableOutOfBandManagementForZoneParams{}
p.p = make(map[string]interface{})
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *ZoneService) NewDisableOutOfBandManagementForZoneParams(zoneid string) *DisableOutOfBandManagementForZoneParams {
p := &DisableOutOfBandManagementForZoneParams{}
p.p = make(map[string]interface{})
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewDisableOutOfBandManagementForZoneParams",
"(",
"zoneid",
"string",
")",
"*",
"DisableOutOfBandManagementForZoneParams",
"{",
"p",
":=",
"&",
"DisableOutOfBandManagementForZoneParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DisableOutOfBandManagementForZoneParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DisableOutOfBandManagementForZoneParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L459-L464
|
145,656 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
DisableOutOfBandManagementForZone
|
func (s *ZoneService) DisableOutOfBandManagementForZone(p *DisableOutOfBandManagementForZoneParams) (*DisableOutOfBandManagementForZoneResponse, error) {
resp, err := s.cs.newRequest("disableOutOfBandManagementForZone", p.toURLValues())
if err != nil {
return nil, err
}
var r DisableOutOfBandManagementForZoneResponse
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 *ZoneService) DisableOutOfBandManagementForZone(p *DisableOutOfBandManagementForZoneParams) (*DisableOutOfBandManagementForZoneResponse, error) {
resp, err := s.cs.newRequest("disableOutOfBandManagementForZone", p.toURLValues())
if err != nil {
return nil, err
}
var r DisableOutOfBandManagementForZoneResponse
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",
"*",
"ZoneService",
")",
"DisableOutOfBandManagementForZone",
"(",
"p",
"*",
"DisableOutOfBandManagementForZoneParams",
")",
"(",
"*",
"DisableOutOfBandManagementForZoneResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DisableOutOfBandManagementForZoneResponse",
"\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 zone
|
[
"Disables",
"out",
"-",
"of",
"-",
"band",
"management",
"for",
"a",
"zone"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L467-L499
|
145,657 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewEnableOutOfBandManagementForZoneParams
|
func (s *ZoneService) NewEnableOutOfBandManagementForZoneParams(zoneid string) *EnableOutOfBandManagementForZoneParams {
p := &EnableOutOfBandManagementForZoneParams{}
p.p = make(map[string]interface{})
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *ZoneService) NewEnableOutOfBandManagementForZoneParams(zoneid string) *EnableOutOfBandManagementForZoneParams {
p := &EnableOutOfBandManagementForZoneParams{}
p.p = make(map[string]interface{})
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewEnableOutOfBandManagementForZoneParams",
"(",
"zoneid",
"string",
")",
"*",
"EnableOutOfBandManagementForZoneParams",
"{",
"p",
":=",
"&",
"EnableOutOfBandManagementForZoneParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new EnableOutOfBandManagementForZoneParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"EnableOutOfBandManagementForZoneParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L541-L546
|
145,658 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
EnableOutOfBandManagementForZone
|
func (s *ZoneService) EnableOutOfBandManagementForZone(p *EnableOutOfBandManagementForZoneParams) (*EnableOutOfBandManagementForZoneResponse, error) {
resp, err := s.cs.newRequest("enableOutOfBandManagementForZone", p.toURLValues())
if err != nil {
return nil, err
}
var r EnableOutOfBandManagementForZoneResponse
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 *ZoneService) EnableOutOfBandManagementForZone(p *EnableOutOfBandManagementForZoneParams) (*EnableOutOfBandManagementForZoneResponse, error) {
resp, err := s.cs.newRequest("enableOutOfBandManagementForZone", p.toURLValues())
if err != nil {
return nil, err
}
var r EnableOutOfBandManagementForZoneResponse
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",
"*",
"ZoneService",
")",
"EnableOutOfBandManagementForZone",
"(",
"p",
"*",
"EnableOutOfBandManagementForZoneParams",
")",
"(",
"*",
"EnableOutOfBandManagementForZoneResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"EnableOutOfBandManagementForZoneResponse",
"\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 zone
|
[
"Enables",
"out",
"-",
"of",
"-",
"band",
"management",
"for",
"a",
"zone"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L549-L581
|
145,659 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewListDedicatedZonesParams
|
func (s *ZoneService) NewListDedicatedZonesParams() *ListDedicatedZonesParams {
p := &ListDedicatedZonesParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *ZoneService) NewListDedicatedZonesParams() *ListDedicatedZonesParams {
p := &ListDedicatedZonesParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewListDedicatedZonesParams",
"(",
")",
"*",
"ListDedicatedZonesParams",
"{",
"p",
":=",
"&",
"ListDedicatedZonesParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListDedicatedZonesParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListDedicatedZonesParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L691-L695
|
145,660 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
ListDedicatedZones
|
func (s *ZoneService) ListDedicatedZones(p *ListDedicatedZonesParams) (*ListDedicatedZonesResponse, error) {
resp, err := s.cs.newRequest("listDedicatedZones", p.toURLValues())
if err != nil {
return nil, err
}
var r ListDedicatedZonesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *ZoneService) ListDedicatedZones(p *ListDedicatedZonesParams) (*ListDedicatedZonesResponse, error) {
resp, err := s.cs.newRequest("listDedicatedZones", p.toURLValues())
if err != nil {
return nil, err
}
var r ListDedicatedZonesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"ListDedicatedZones",
"(",
"p",
"*",
"ListDedicatedZonesParams",
")",
"(",
"*",
"ListDedicatedZonesResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListDedicatedZonesResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// List dedicated zones.
|
[
"List",
"dedicated",
"zones",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L698-L710
|
145,661 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewListZonesParams
|
func (s *ZoneService) NewListZonesParams() *ListZonesParams {
p := &ListZonesParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *ZoneService) NewListZonesParams() *ListZonesParams {
p := &ListZonesParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewListZonesParams",
"(",
")",
"*",
"ListZonesParams",
"{",
"p",
":=",
"&",
"ListZonesParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListZonesParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListZonesParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L859-L863
|
145,662 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewReleaseDedicatedZoneParams
|
func (s *ZoneService) NewReleaseDedicatedZoneParams(zoneid string) *ReleaseDedicatedZoneParams {
p := &ReleaseDedicatedZoneParams{}
p.p = make(map[string]interface{})
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *ZoneService) NewReleaseDedicatedZoneParams(zoneid string) *ReleaseDedicatedZoneParams {
p := &ReleaseDedicatedZoneParams{}
p.p = make(map[string]interface{})
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewReleaseDedicatedZoneParams",
"(",
"zoneid",
"string",
")",
"*",
"ReleaseDedicatedZoneParams",
"{",
"p",
":=",
"&",
"ReleaseDedicatedZoneParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ReleaseDedicatedZoneParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ReleaseDedicatedZoneParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L1034-L1039
|
145,663 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
ReleaseDedicatedZone
|
func (s *ZoneService) ReleaseDedicatedZone(p *ReleaseDedicatedZoneParams) (*ReleaseDedicatedZoneResponse, error) {
resp, err := s.cs.newRequest("releaseDedicatedZone", p.toURLValues())
if err != nil {
return nil, err
}
var r ReleaseDedicatedZoneResponse
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 *ZoneService) ReleaseDedicatedZone(p *ReleaseDedicatedZoneParams) (*ReleaseDedicatedZoneResponse, error) {
resp, err := s.cs.newRequest("releaseDedicatedZone", p.toURLValues())
if err != nil {
return nil, err
}
var r ReleaseDedicatedZoneResponse
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",
"*",
"ZoneService",
")",
"ReleaseDedicatedZone",
"(",
"p",
"*",
"ReleaseDedicatedZoneParams",
")",
"(",
"*",
"ReleaseDedicatedZoneResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ReleaseDedicatedZoneResponse",
"\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",
"}"
] |
// Release dedication of zone
|
[
"Release",
"dedication",
"of",
"zone"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L1042-L1069
|
145,664 |
xanzy/go-cloudstack
|
cloudstack/ZoneService.go
|
NewUpdateZoneParams
|
func (s *ZoneService) NewUpdateZoneParams(id string) *UpdateZoneParams {
p := &UpdateZoneParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *ZoneService) NewUpdateZoneParams(id string) *UpdateZoneParams {
p := &UpdateZoneParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"ZoneService",
")",
"NewUpdateZoneParams",
"(",
"id",
"string",
")",
"*",
"UpdateZoneParams",
"{",
"p",
":=",
"&",
"UpdateZoneParams",
"{",
"}",
"\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 UpdateZoneParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateZoneParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/ZoneService.go#L1274-L1279
|
145,665 |
xanzy/go-cloudstack
|
cloudstack/OvsElementService.go
|
NewConfigureOvsElementParams
|
func (s *OvsElementService) NewConfigureOvsElementParams(enabled bool, id string) *ConfigureOvsElementParams {
p := &ConfigureOvsElementParams{}
p.p = make(map[string]interface{})
p.p["enabled"] = enabled
p.p["id"] = id
return p
}
|
go
|
func (s *OvsElementService) NewConfigureOvsElementParams(enabled bool, id string) *ConfigureOvsElementParams {
p := &ConfigureOvsElementParams{}
p.p = make(map[string]interface{})
p.p["enabled"] = enabled
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"OvsElementService",
")",
"NewConfigureOvsElementParams",
"(",
"enabled",
"bool",
",",
"id",
"string",
")",
"*",
"ConfigureOvsElementParams",
"{",
"p",
":=",
"&",
"ConfigureOvsElementParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"enabled",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ConfigureOvsElementParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ConfigureOvsElementParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/OvsElementService.go#L64-L70
|
145,666 |
xanzy/go-cloudstack
|
cloudstack/OvsElementService.go
|
ConfigureOvsElement
|
func (s *OvsElementService) ConfigureOvsElement(p *ConfigureOvsElementParams) (*OvsElementResponse, error) {
resp, err := s.cs.newRequest("configureOvsElement", p.toURLValues())
if err != nil {
return nil, err
}
var r OvsElementResponse
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 *OvsElementService) ConfigureOvsElement(p *ConfigureOvsElementParams) (*OvsElementResponse, error) {
resp, err := s.cs.newRequest("configureOvsElement", p.toURLValues())
if err != nil {
return nil, err
}
var r OvsElementResponse
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",
"*",
"OvsElementService",
")",
"ConfigureOvsElement",
"(",
"p",
"*",
"ConfigureOvsElementParams",
")",
"(",
"*",
"OvsElementResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"OvsElementResponse",
"\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",
"}"
] |
// Configures an ovs element.
|
[
"Configures",
"an",
"ovs",
"element",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/OvsElementService.go#L73-L105
|
145,667 |
xanzy/go-cloudstack
|
cloudstack/OvsElementService.go
|
NewListOvsElementsParams
|
func (s *OvsElementService) NewListOvsElementsParams() *ListOvsElementsParams {
p := &ListOvsElementsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *OvsElementService) NewListOvsElementsParams() *ListOvsElementsParams {
p := &ListOvsElementsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"OvsElementService",
")",
"NewListOvsElementsParams",
"(",
")",
"*",
"ListOvsElementsParams",
"{",
"p",
":=",
"&",
"ListOvsElementsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListOvsElementsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListOvsElementsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/OvsElementService.go#L202-L206
|
145,668 |
xanzy/go-cloudstack
|
cloudstack/OvsElementService.go
|
ListOvsElements
|
func (s *OvsElementService) ListOvsElements(p *ListOvsElementsParams) (*ListOvsElementsResponse, error) {
resp, err := s.cs.newRequest("listOvsElements", p.toURLValues())
if err != nil {
return nil, err
}
var r ListOvsElementsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *OvsElementService) ListOvsElements(p *ListOvsElementsParams) (*ListOvsElementsResponse, error) {
resp, err := s.cs.newRequest("listOvsElements", p.toURLValues())
if err != nil {
return nil, err
}
var r ListOvsElementsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"OvsElementService",
")",
"ListOvsElements",
"(",
"p",
"*",
"ListOvsElementsParams",
")",
"(",
"*",
"ListOvsElementsResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListOvsElementsResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Lists all available ovs elements.
|
[
"Lists",
"all",
"available",
"ovs",
"elements",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/OvsElementService.go#L242-L254
|
145,669 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
NewChangeServiceForSystemVmParams
|
func (s *SystemVMService) NewChangeServiceForSystemVmParams(id string, serviceofferingid string) *ChangeServiceForSystemVmParams {
p := &ChangeServiceForSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["serviceofferingid"] = serviceofferingid
return p
}
|
go
|
func (s *SystemVMService) NewChangeServiceForSystemVmParams(id string, serviceofferingid string) *ChangeServiceForSystemVmParams {
p := &ChangeServiceForSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["serviceofferingid"] = serviceofferingid
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"NewChangeServiceForSystemVmParams",
"(",
"id",
"string",
",",
"serviceofferingid",
"string",
")",
"*",
"ChangeServiceForSystemVmParams",
"{",
"p",
":=",
"&",
"ChangeServiceForSystemVmParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"serviceofferingid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ChangeServiceForSystemVmParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ChangeServiceForSystemVmParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L78-L84
|
145,670 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
NewDestroySystemVmParams
|
func (s *SystemVMService) NewDestroySystemVmParams(id string) *DestroySystemVmParams {
p := &DestroySystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *SystemVMService) NewDestroySystemVmParams(id string) *DestroySystemVmParams {
p := &DestroySystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"NewDestroySystemVmParams",
"(",
"id",
"string",
")",
"*",
"DestroySystemVmParams",
"{",
"p",
":=",
"&",
"DestroySystemVmParams",
"{",
"}",
"\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 DestroySystemVmParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DestroySystemVmParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L159-L164
|
145,671 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
DestroySystemVm
|
func (s *SystemVMService) DestroySystemVm(p *DestroySystemVmParams) (*DestroySystemVmResponse, error) {
resp, err := s.cs.newRequest("destroySystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r DestroySystemVmResponse
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 *SystemVMService) DestroySystemVm(p *DestroySystemVmParams) (*DestroySystemVmResponse, error) {
resp, err := s.cs.newRequest("destroySystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r DestroySystemVmResponse
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",
"*",
"SystemVMService",
")",
"DestroySystemVm",
"(",
"p",
"*",
"DestroySystemVmParams",
")",
"(",
"*",
"DestroySystemVmResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"DestroySystemVmResponse",
"\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",
"}"
] |
// Destroyes a system virtual machine.
|
[
"Destroyes",
"a",
"system",
"virtual",
"machine",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L167-L199
|
145,672 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
NewListSystemVmsParams
|
func (s *SystemVMService) NewListSystemVmsParams() *ListSystemVmsParams {
p := &ListSystemVmsParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *SystemVMService) NewListSystemVmsParams() *ListSystemVmsParams {
p := &ListSystemVmsParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"NewListSystemVmsParams",
"(",
")",
"*",
"ListSystemVmsParams",
"{",
"p",
":=",
"&",
"ListSystemVmsParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListSystemVmsParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListSystemVmsParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L371-L375
|
145,673 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
ListSystemVms
|
func (s *SystemVMService) ListSystemVms(p *ListSystemVmsParams) (*ListSystemVmsResponse, error) {
resp, err := s.cs.newRequest("listSystemVms", p.toURLValues())
if err != nil {
return nil, err
}
var r ListSystemVmsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *SystemVMService) ListSystemVms(p *ListSystemVmsParams) (*ListSystemVmsResponse, error) {
resp, err := s.cs.newRequest("listSystemVms", p.toURLValues())
if err != nil {
return nil, err
}
var r ListSystemVmsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"ListSystemVms",
"(",
"p",
"*",
"ListSystemVmsParams",
")",
"(",
"*",
"ListSystemVmsResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"ListSystemVmsResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// List system virtual machines.
|
[
"List",
"system",
"virtual",
"machines",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L461-L473
|
145,674 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
NewMigrateSystemVmParams
|
func (s *SystemVMService) NewMigrateSystemVmParams(hostid string, virtualmachineid string) *MigrateSystemVmParams {
p := &MigrateSystemVmParams{}
p.p = make(map[string]interface{})
p.p["hostid"] = hostid
p.p["virtualmachineid"] = virtualmachineid
return p
}
|
go
|
func (s *SystemVMService) NewMigrateSystemVmParams(hostid string, virtualmachineid string) *MigrateSystemVmParams {
p := &MigrateSystemVmParams{}
p.p = make(map[string]interface{})
p.p["hostid"] = hostid
p.p["virtualmachineid"] = virtualmachineid
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"NewMigrateSystemVmParams",
"(",
"hostid",
"string",
",",
"virtualmachineid",
"string",
")",
"*",
"MigrateSystemVmParams",
"{",
"p",
":=",
"&",
"MigrateSystemVmParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"hostid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"virtualmachineid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new MigrateSystemVmParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"MigrateSystemVmParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L549-L555
|
145,675 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
MigrateSystemVm
|
func (s *SystemVMService) MigrateSystemVm(p *MigrateSystemVmParams) (*MigrateSystemVmResponse, error) {
resp, err := s.cs.newRequest("migrateSystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r MigrateSystemVmResponse
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 *SystemVMService) MigrateSystemVm(p *MigrateSystemVmParams) (*MigrateSystemVmResponse, error) {
resp, err := s.cs.newRequest("migrateSystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r MigrateSystemVmResponse
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",
"*",
"SystemVMService",
")",
"MigrateSystemVm",
"(",
"p",
"*",
"MigrateSystemVmParams",
")",
"(",
"*",
"MigrateSystemVmResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"MigrateSystemVmResponse",
"\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",
"}"
] |
// Attempts Migration of a system virtual machine to the host specified.
|
[
"Attempts",
"Migration",
"of",
"a",
"system",
"virtual",
"machine",
"to",
"the",
"host",
"specified",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L558-L590
|
145,676 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
NewRebootSystemVmParams
|
func (s *SystemVMService) NewRebootSystemVmParams(id string) *RebootSystemVmParams {
p := &RebootSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *SystemVMService) NewRebootSystemVmParams(id string) *RebootSystemVmParams {
p := &RebootSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"NewRebootSystemVmParams",
"(",
"id",
"string",
")",
"*",
"RebootSystemVmParams",
"{",
"p",
":=",
"&",
"RebootSystemVmParams",
"{",
"}",
"\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 RebootSystemVmParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"RebootSystemVmParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L650-L655
|
145,677 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
RebootSystemVm
|
func (s *SystemVMService) RebootSystemVm(p *RebootSystemVmParams) (*RebootSystemVmResponse, error) {
resp, err := s.cs.newRequest("rebootSystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r RebootSystemVmResponse
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 *SystemVMService) RebootSystemVm(p *RebootSystemVmParams) (*RebootSystemVmResponse, error) {
resp, err := s.cs.newRequest("rebootSystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r RebootSystemVmResponse
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",
"*",
"SystemVMService",
")",
"RebootSystemVm",
"(",
"p",
"*",
"RebootSystemVmParams",
")",
"(",
"*",
"RebootSystemVmResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"RebootSystemVmResponse",
"\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",
"}"
] |
// Reboots a system VM.
|
[
"Reboots",
"a",
"system",
"VM",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L658-L690
|
145,678 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
NewScaleSystemVmParams
|
func (s *SystemVMService) NewScaleSystemVmParams(id string, serviceofferingid string) *ScaleSystemVmParams {
p := &ScaleSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["serviceofferingid"] = serviceofferingid
return p
}
|
go
|
func (s *SystemVMService) NewScaleSystemVmParams(id string, serviceofferingid string) *ScaleSystemVmParams {
p := &ScaleSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["serviceofferingid"] = serviceofferingid
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"NewScaleSystemVmParams",
"(",
"id",
"string",
",",
"serviceofferingid",
"string",
")",
"*",
"ScaleSystemVmParams",
"{",
"p",
":=",
"&",
"ScaleSystemVmParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"serviceofferingid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ScaleSystemVmParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ScaleSystemVmParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L776-L782
|
145,679 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
NewStartSystemVmParams
|
func (s *SystemVMService) NewStartSystemVmParams(id string) *StartSystemVmParams {
p := &StartSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *SystemVMService) NewStartSystemVmParams(id string) *StartSystemVmParams {
p := &StartSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"NewStartSystemVmParams",
"(",
"id",
"string",
")",
"*",
"StartSystemVmParams",
"{",
"p",
":=",
"&",
"StartSystemVmParams",
"{",
"}",
"\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 StartSystemVmParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"StartSystemVmParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L877-L882
|
145,680 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
StartSystemVm
|
func (s *SystemVMService) StartSystemVm(p *StartSystemVmParams) (*StartSystemVmResponse, error) {
resp, err := s.cs.newRequest("startSystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r StartSystemVmResponse
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 *SystemVMService) StartSystemVm(p *StartSystemVmParams) (*StartSystemVmResponse, error) {
resp, err := s.cs.newRequest("startSystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r StartSystemVmResponse
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",
"*",
"SystemVMService",
")",
"StartSystemVm",
"(",
"p",
"*",
"StartSystemVmParams",
")",
"(",
"*",
"StartSystemVmResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"StartSystemVmResponse",
"\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",
"}"
] |
// Starts a system virtual machine.
|
[
"Starts",
"a",
"system",
"virtual",
"machine",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L885-L917
|
145,681 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
NewStopSystemVmParams
|
func (s *SystemVMService) NewStopSystemVmParams(id string) *StopSystemVmParams {
p := &StopSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *SystemVMService) NewStopSystemVmParams(id string) *StopSystemVmParams {
p := &StopSystemVmParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"SystemVMService",
")",
"NewStopSystemVmParams",
"(",
"id",
"string",
")",
"*",
"StopSystemVmParams",
"{",
"p",
":=",
"&",
"StopSystemVmParams",
"{",
"}",
"\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 StopSystemVmParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"StopSystemVmParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L989-L994
|
145,682 |
xanzy/go-cloudstack
|
cloudstack/SystemVMService.go
|
StopSystemVm
|
func (s *SystemVMService) StopSystemVm(p *StopSystemVmParams) (*StopSystemVmResponse, error) {
resp, err := s.cs.newRequest("stopSystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r StopSystemVmResponse
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 *SystemVMService) StopSystemVm(p *StopSystemVmParams) (*StopSystemVmResponse, error) {
resp, err := s.cs.newRequest("stopSystemVm", p.toURLValues())
if err != nil {
return nil, err
}
var r StopSystemVmResponse
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",
"*",
"SystemVMService",
")",
"StopSystemVm",
"(",
"p",
"*",
"StopSystemVmParams",
")",
"(",
"*",
"StopSystemVmResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"StopSystemVmResponse",
"\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",
"}"
] |
// Stops a system VM.
|
[
"Stops",
"a",
"system",
"VM",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/SystemVMService.go#L997-L1029
|
145,683 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewAttachVolumeParams
|
func (s *VolumeService) NewAttachVolumeParams(id string, virtualmachineid string) *AttachVolumeParams {
p := &AttachVolumeParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["virtualmachineid"] = virtualmachineid
return p
}
|
go
|
func (s *VolumeService) NewAttachVolumeParams(id string, virtualmachineid string) *AttachVolumeParams {
p := &AttachVolumeParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["virtualmachineid"] = virtualmachineid
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewAttachVolumeParams",
"(",
"id",
"string",
",",
"virtualmachineid",
"string",
")",
"*",
"AttachVolumeParams",
"{",
"p",
":=",
"&",
"AttachVolumeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"virtualmachineid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new AttachVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"AttachVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L75-L81
|
145,684 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewCreateVolumeParams
|
func (s *VolumeService) NewCreateVolumeParams() *CreateVolumeParams {
p := &CreateVolumeParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *VolumeService) NewCreateVolumeParams() *CreateVolumeParams {
p := &CreateVolumeParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewCreateVolumeParams",
"(",
")",
"*",
"CreateVolumeParams",
"{",
"p",
":=",
"&",
"CreateVolumeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new CreateVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"CreateVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L340-L344
|
145,685 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewDeleteVolumeParams
|
func (s *VolumeService) NewDeleteVolumeParams(id string) *DeleteVolumeParams {
p := &DeleteVolumeParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VolumeService) NewDeleteVolumeParams(id string) *DeleteVolumeParams {
p := &DeleteVolumeParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewDeleteVolumeParams",
"(",
"id",
"string",
")",
"*",
"DeleteVolumeParams",
"{",
"p",
":=",
"&",
"DeleteVolumeParams",
"{",
"}",
"\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 DeleteVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DeleteVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L467-L472
|
145,686 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewDetachVolumeParams
|
func (s *VolumeService) NewDetachVolumeParams() *DetachVolumeParams {
p := &DetachVolumeParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *VolumeService) NewDetachVolumeParams() *DetachVolumeParams {
p := &DetachVolumeParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewDetachVolumeParams",
"(",
")",
"*",
"DetachVolumeParams",
"{",
"p",
":=",
"&",
"DetachVolumeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new DetachVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"DetachVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L561-L565
|
145,687 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewExtractVolumeParams
|
func (s *VolumeService) NewExtractVolumeParams(id string, mode string, zoneid string) *ExtractVolumeParams {
p := &ExtractVolumeParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["mode"] = mode
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *VolumeService) NewExtractVolumeParams(id string, mode string, zoneid string) *ExtractVolumeParams {
p := &ExtractVolumeParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
p.p["mode"] = mode
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewExtractVolumeParams",
"(",
"id",
"string",
",",
"mode",
"string",
",",
"zoneid",
"string",
")",
"*",
"ExtractVolumeParams",
"{",
"p",
":=",
"&",
"ExtractVolumeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"id",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"mode",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ExtractVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ExtractVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L721-L728
|
145,688 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewGetPathForVolumeParams
|
func (s *VolumeService) NewGetPathForVolumeParams(volumeid string) *GetPathForVolumeParams {
p := &GetPathForVolumeParams{}
p.p = make(map[string]interface{})
p.p["volumeid"] = volumeid
return p
}
|
go
|
func (s *VolumeService) NewGetPathForVolumeParams(volumeid string) *GetPathForVolumeParams {
p := &GetPathForVolumeParams{}
p.p = make(map[string]interface{})
p.p["volumeid"] = volumeid
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewGetPathForVolumeParams",
"(",
"volumeid",
"string",
")",
"*",
"GetPathForVolumeParams",
"{",
"p",
":=",
"&",
"GetPathForVolumeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"volumeid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new GetPathForVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"GetPathForVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L808-L813
|
145,689 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
GetPathForVolume
|
func (s *VolumeService) GetPathForVolume(p *GetPathForVolumeParams) (*GetPathForVolumeResponse, error) {
resp, err := s.cs.newRequest("getPathForVolume", p.toURLValues())
if err != nil {
return nil, err
}
var r GetPathForVolumeResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *VolumeService) GetPathForVolume(p *GetPathForVolumeParams) (*GetPathForVolumeResponse, error) {
resp, err := s.cs.newRequest("getPathForVolume", p.toURLValues())
if err != nil {
return nil, err
}
var r GetPathForVolumeResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"GetPathForVolume",
"(",
"p",
"*",
"GetPathForVolumeParams",
")",
"(",
"*",
"GetPathForVolumeResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"GetPathForVolumeResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Get the path associated with the provided volume UUID
|
[
"Get",
"the",
"path",
"associated",
"with",
"the",
"provided",
"volume",
"UUID"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L816-L828
|
145,690 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewGetSolidFireVolumeSizeParams
|
func (s *VolumeService) NewGetSolidFireVolumeSizeParams(volumeid string) *GetSolidFireVolumeSizeParams {
p := &GetSolidFireVolumeSizeParams{}
p.p = make(map[string]interface{})
p.p["volumeid"] = volumeid
return p
}
|
go
|
func (s *VolumeService) NewGetSolidFireVolumeSizeParams(volumeid string) *GetSolidFireVolumeSizeParams {
p := &GetSolidFireVolumeSizeParams{}
p.p = make(map[string]interface{})
p.p["volumeid"] = volumeid
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewGetSolidFireVolumeSizeParams",
"(",
"volumeid",
"string",
")",
"*",
"GetSolidFireVolumeSizeParams",
"{",
"p",
":=",
"&",
"GetSolidFireVolumeSizeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"volumeid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new GetSolidFireVolumeSizeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"GetSolidFireVolumeSizeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L859-L864
|
145,691 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
GetSolidFireVolumeSize
|
func (s *VolumeService) GetSolidFireVolumeSize(p *GetSolidFireVolumeSizeParams) (*GetSolidFireVolumeSizeResponse, error) {
resp, err := s.cs.newRequest("getSolidFireVolumeSize", p.toURLValues())
if err != nil {
return nil, err
}
var r GetSolidFireVolumeSizeResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *VolumeService) GetSolidFireVolumeSize(p *GetSolidFireVolumeSizeParams) (*GetSolidFireVolumeSizeResponse, error) {
resp, err := s.cs.newRequest("getSolidFireVolumeSize", p.toURLValues())
if err != nil {
return nil, err
}
var r GetSolidFireVolumeSizeResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"GetSolidFireVolumeSize",
"(",
"p",
"*",
"GetSolidFireVolumeSizeParams",
")",
"(",
"*",
"GetSolidFireVolumeSizeResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"GetSolidFireVolumeSizeResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Get the SF volume size including Hypervisor Snapshot Reserve
|
[
"Get",
"the",
"SF",
"volume",
"size",
"including",
"Hypervisor",
"Snapshot",
"Reserve"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L867-L879
|
145,692 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewGetUploadParamsForVolumeParams
|
func (s *VolumeService) NewGetUploadParamsForVolumeParams(format string, name string, zoneid string) *GetUploadParamsForVolumeParams {
p := &GetUploadParamsForVolumeParams{}
p.p = make(map[string]interface{})
p.p["format"] = format
p.p["name"] = name
p.p["zoneid"] = zoneid
return p
}
|
go
|
func (s *VolumeService) NewGetUploadParamsForVolumeParams(format string, name string, zoneid string) *GetUploadParamsForVolumeParams {
p := &GetUploadParamsForVolumeParams{}
p.p = make(map[string]interface{})
p.p["format"] = format
p.p["name"] = name
p.p["zoneid"] = zoneid
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewGetUploadParamsForVolumeParams",
"(",
"format",
"string",
",",
"name",
"string",
",",
"zoneid",
"string",
")",
"*",
"GetUploadParamsForVolumeParams",
"{",
"p",
":=",
"&",
"GetUploadParamsForVolumeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"format",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"name",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"zoneid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new GetUploadParamsForVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"GetUploadParamsForVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L998-L1005
|
145,693 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
GetUploadParamsForVolume
|
func (s *VolumeService) GetUploadParamsForVolume(p *GetUploadParamsForVolumeParams) (*GetUploadParamsForVolumeResponse, error) {
resp, err := s.cs.newRequest("getUploadParamsForVolume", p.toURLValues())
if err != nil {
return nil, err
}
var r GetUploadParamsForVolumeResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *VolumeService) GetUploadParamsForVolume(p *GetUploadParamsForVolumeParams) (*GetUploadParamsForVolumeResponse, error) {
resp, err := s.cs.newRequest("getUploadParamsForVolume", p.toURLValues())
if err != nil {
return nil, err
}
var r GetUploadParamsForVolumeResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"GetUploadParamsForVolume",
"(",
"p",
"*",
"GetUploadParamsForVolumeParams",
")",
"(",
"*",
"GetUploadParamsForVolumeResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"GetUploadParamsForVolumeResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Upload a data disk to the cloudstack cloud.
|
[
"Upload",
"a",
"data",
"disk",
"to",
"the",
"cloudstack",
"cloud",
"."
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L1008-L1020
|
145,694 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewGetVolumeiScsiNameParams
|
func (s *VolumeService) NewGetVolumeiScsiNameParams(volumeid string) *GetVolumeiScsiNameParams {
p := &GetVolumeiScsiNameParams{}
p.p = make(map[string]interface{})
p.p["volumeid"] = volumeid
return p
}
|
go
|
func (s *VolumeService) NewGetVolumeiScsiNameParams(volumeid string) *GetVolumeiScsiNameParams {
p := &GetVolumeiScsiNameParams{}
p.p = make(map[string]interface{})
p.p["volumeid"] = volumeid
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewGetVolumeiScsiNameParams",
"(",
"volumeid",
"string",
")",
"*",
"GetVolumeiScsiNameParams",
"{",
"p",
":=",
"&",
"GetVolumeiScsiNameParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"volumeid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new GetVolumeiScsiNameParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"GetVolumeiScsiNameParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L1055-L1060
|
145,695 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
GetVolumeiScsiName
|
func (s *VolumeService) GetVolumeiScsiName(p *GetVolumeiScsiNameParams) (*GetVolumeiScsiNameResponse, error) {
resp, err := s.cs.newRequest("getVolumeiScsiName", p.toURLValues())
if err != nil {
return nil, err
}
var r GetVolumeiScsiNameResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
go
|
func (s *VolumeService) GetVolumeiScsiName(p *GetVolumeiScsiNameParams) (*GetVolumeiScsiNameResponse, error) {
resp, err := s.cs.newRequest("getVolumeiScsiName", p.toURLValues())
if err != nil {
return nil, err
}
var r GetVolumeiScsiNameResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"GetVolumeiScsiName",
"(",
"p",
"*",
"GetVolumeiScsiNameParams",
")",
"(",
"*",
"GetVolumeiScsiNameResponse",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"s",
".",
"cs",
".",
"newRequest",
"(",
"\"",
"\"",
",",
"p",
".",
"toURLValues",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"r",
"GetVolumeiScsiNameResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}"
] |
// Get Volume's iSCSI Name
|
[
"Get",
"Volume",
"s",
"iSCSI",
"Name"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L1063-L1075
|
145,696 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewListVolumesParams
|
func (s *VolumeService) NewListVolumesParams() *ListVolumesParams {
p := &ListVolumesParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *VolumeService) NewListVolumesParams() *ListVolumesParams {
p := &ListVolumesParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewListVolumesParams",
"(",
")",
"*",
"ListVolumesParams",
"{",
"p",
":=",
"&",
"ListVolumesParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new ListVolumesParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ListVolumesParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L1337-L1341
|
145,697 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewMigrateVolumeParams
|
func (s *VolumeService) NewMigrateVolumeParams(storageid string, volumeid string) *MigrateVolumeParams {
p := &MigrateVolumeParams{}
p.p = make(map[string]interface{})
p.p["storageid"] = storageid
p.p["volumeid"] = volumeid
return p
}
|
go
|
func (s *VolumeService) NewMigrateVolumeParams(storageid string, volumeid string) *MigrateVolumeParams {
p := &MigrateVolumeParams{}
p.p = make(map[string]interface{})
p.p["storageid"] = storageid
p.p["volumeid"] = volumeid
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewMigrateVolumeParams",
"(",
"storageid",
"string",
",",
"volumeid",
"string",
")",
"*",
"MigrateVolumeParams",
"{",
"p",
":=",
"&",
"MigrateVolumeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"storageid",
"\n",
"p",
".",
"p",
"[",
"\"",
"\"",
"]",
"=",
"volumeid",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new MigrateVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"MigrateVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L1554-L1560
|
145,698 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewResizeVolumeParams
|
func (s *VolumeService) NewResizeVolumeParams(id string) *ResizeVolumeParams {
p := &ResizeVolumeParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
go
|
func (s *VolumeService) NewResizeVolumeParams(id string) *ResizeVolumeParams {
p := &ResizeVolumeParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewResizeVolumeParams",
"(",
"id",
"string",
")",
"*",
"ResizeVolumeParams",
"{",
"p",
":=",
"&",
"ResizeVolumeParams",
"{",
"}",
"\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 ResizeVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"ResizeVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L1742-L1747
|
145,699 |
xanzy/go-cloudstack
|
cloudstack/VolumeService.go
|
NewUpdateVolumeParams
|
func (s *VolumeService) NewUpdateVolumeParams() *UpdateVolumeParams {
p := &UpdateVolumeParams{}
p.p = make(map[string]interface{})
return p
}
|
go
|
func (s *VolumeService) NewUpdateVolumeParams() *UpdateVolumeParams {
p := &UpdateVolumeParams{}
p.p = make(map[string]interface{})
return p
}
|
[
"func",
"(",
"s",
"*",
"VolumeService",
")",
"NewUpdateVolumeParams",
"(",
")",
"*",
"UpdateVolumeParams",
"{",
"p",
":=",
"&",
"UpdateVolumeParams",
"{",
"}",
"\n",
"p",
".",
"p",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"return",
"p",
"\n",
"}"
] |
// You should always use this function to get a new UpdateVolumeParams instance,
// as then you are sure you have configured all required params
|
[
"You",
"should",
"always",
"use",
"this",
"function",
"to",
"get",
"a",
"new",
"UpdateVolumeParams",
"instance",
"as",
"then",
"you",
"are",
"sure",
"you",
"have",
"configured",
"all",
"required",
"params"
] |
b6f53ed3282d22b6446422879587b0a78e1b0f11
|
https://github.com/xanzy/go-cloudstack/blob/b6f53ed3282d22b6446422879587b0a78e1b0f11/cloudstack/VolumeService.go#L1937-L1941
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.