//
// Copyright 2016, Sander van Harmelen
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package cloudstack
import (
"encoding/json"
"fmt"
"net/url"
"strconv"
"strings"
)
// Helper function for maintaining backwards compatibility
func convertFirewallServiceResponse(b []byte) ([]byte, error) {
var raw map[string]interface{}
if err := json.Unmarshal(b, &raw); err != nil {
return nil, err
}
if _, ok := raw["firewallrule"]; ok {
return convertFirewallServiceListResponse(b)
}
for _, k := range []string{"endport", "startport"} {
if sVal, ok := raw[k].(string); ok {
iVal, err := strconv.Atoi(sVal)
if err != nil {
return nil, err
}
raw[k] = iVal
}
}
return json.Marshal(raw)
}
// Helper function for maintaining backwards compatibility
func convertFirewallServiceListResponse(b []byte) ([]byte, error) {
var rawList struct {
Count int `json:"count"`
FirewallRules []map[string]interface{} `json:"firewallrule"`
}
if err := json.Unmarshal(b, &rawList); err != nil {
return nil, err
}
for _, r := range rawList.FirewallRules {
for _, k := range []string{"endport", "startport"} {
if sVal, ok := r[k].(string); ok {
iVal, err := strconv.Atoi(sVal)
if err != nil {
return nil, err
}
r[k] = iVal
}
}
}
return json.Marshal(rawList)
}
type ListPortForwardingRulesParams struct {
p map[string]interface{}
}
func (p *ListPortForwardingRulesParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["account"]; found {
u.Set("account", v.(string))
}
if v, found := p.p["domainid"]; found {
u.Set("domainid", v.(string))
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
if v, found := p.p["ipaddressid"]; found {
u.Set("ipaddressid", v.(string))
}
if v, found := p.p["isrecursive"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("isrecursive", vv)
}
if v, found := p.p["keyword"]; found {
u.Set("keyword", v.(string))
}
if v, found := p.p["listall"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("listall", vv)
}
if v, found := p.p["networkid"]; found {
u.Set("networkid", v.(string))
}
if v, found := p.p["page"]; found {
vv := strconv.Itoa(v.(int))
u.Set("page", vv)
}
if v, found := p.p["pagesize"]; found {
vv := strconv.Itoa(v.(int))
u.Set("pagesize", vv)
}
if v, found := p.p["projectid"]; found {
u.Set("projectid", v.(string))
}
if v, found := p.p["tags"]; found {
i := 0
for k, vv := range v.(map[string]string) {
u.Set(fmt.Sprintf("tags[%d].key", i), k)
u.Set(fmt.Sprintf("tags[%d].value", i), vv)
i++
}
}
return u
}
func (p *ListPortForwardingRulesParams) SetAccount(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["account"] = v
return
}
func (p *ListPortForwardingRulesParams) SetDomainid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["domainid"] = v
return
}
func (p *ListPortForwardingRulesParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *ListPortForwardingRulesParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
func (p *ListPortForwardingRulesParams) SetIpaddressid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["ipaddressid"] = v
return
}
func (p *ListPortForwardingRulesParams) SetIsrecursive(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["isrecursive"] = v
return
}
func (p *ListPortForwardingRulesParams) SetKeyword(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["keyword"] = v
return
}
func (p *ListPortForwardingRulesParams) SetListall(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["listall"] = v
return
}
func (p *ListPortForwardingRulesParams) SetNetworkid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["networkid"] = v
return
}
func (p *ListPortForwardingRulesParams) SetPage(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["page"] = v
return
}
func (p *ListPortForwardingRulesParams) SetPagesize(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["pagesize"] = v
return
}
func (p *ListPortForwardingRulesParams) SetProjectid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["projectid"] = v
return
}
func (p *ListPortForwardingRulesParams) SetTags(v map[string]string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["tags"] = v
return
}
// You should always use this function to get a new ListPortForwardingRulesParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewListPortForwardingRulesParams() *ListPortForwardingRulesParams {
p := &ListPortForwardingRulesParams{}
p.p = make(map[string]interface{})
return p
}
// This is a courtesy helper function, which in some cases may not work as expected!
func (s *FirewallService) GetPortForwardingRuleByID(id string, opts ...OptionFunc) (*PortForwardingRule, int, error) {
p := &ListPortForwardingRulesParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
for _, fn := range opts {
if err := fn(s.cs, p); err != nil {
return nil, -1, err
}
}
l, err := s.ListPortForwardingRules(p)
if err != nil {
if strings.Contains(err.Error(), fmt.Sprintf(
"Invalid parameter id value=%s due to incorrect long value format, "+
"or entity does not exist", id)) {
return nil, 0, fmt.Errorf("No match found for %s: %+v", id, l)
}
return nil, -1, err
}
if l.Count == 0 {
return nil, l.Count, fmt.Errorf("No match found for %s: %+v", id, l)
}
if l.Count == 1 {
return l.PortForwardingRules[0], l.Count, nil
}
return nil, l.Count, fmt.Errorf("There is more then one result for PortForwardingRule UUID: %s!", id)
}
// Lists all port forwarding rules for an IP address.
func (s *FirewallService) ListPortForwardingRules(p *ListPortForwardingRulesParams) (*ListPortForwardingRulesResponse, error) {
resp, err := s.cs.newRequest("listPortForwardingRules", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r ListPortForwardingRulesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
type ListPortForwardingRulesResponse struct {
Count int `json:"count"`
PortForwardingRules []*PortForwardingRule `json:"portforwardingrule"`
}
type PortForwardingRule struct {
Cidrlist string `json:"cidrlist,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Privateendport string `json:"privateendport,omitempty"`
Privateport string `json:"privateport,omitempty"`
Protocol string `json:"protocol,omitempty"`
Publicendport string `json:"publicendport,omitempty"`
Publicport string `json:"publicport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
Virtualmachinedisplayname string `json:"virtualmachinedisplayname,omitempty"`
Virtualmachineid string `json:"virtualmachineid,omitempty"`
Virtualmachinename string `json:"virtualmachinename,omitempty"`
Vmguestip string `json:"vmguestip,omitempty"`
}
type CreatePortForwardingRuleParams struct {
p map[string]interface{}
}
func (p *CreatePortForwardingRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["cidrlist"]; found {
vv := strings.Join(v.([]string), ",")
u.Set("cidrlist", vv)
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["ipaddressid"]; found {
u.Set("ipaddressid", v.(string))
}
if v, found := p.p["networkid"]; found {
u.Set("networkid", v.(string))
}
if v, found := p.p["openfirewall"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("openfirewall", vv)
}
if v, found := p.p["privateendport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("privateendport", vv)
}
if v, found := p.p["privateport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("privateport", vv)
}
if v, found := p.p["protocol"]; found {
u.Set("protocol", v.(string))
}
if v, found := p.p["publicendport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("publicendport", vv)
}
if v, found := p.p["publicport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("publicport", vv)
}
if v, found := p.p["virtualmachineid"]; found {
u.Set("virtualmachineid", v.(string))
}
if v, found := p.p["vmguestip"]; found {
u.Set("vmguestip", v.(string))
}
return u
}
func (p *CreatePortForwardingRuleParams) SetCidrlist(v []string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["cidrlist"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetIpaddressid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["ipaddressid"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetNetworkid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["networkid"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetOpenfirewall(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["openfirewall"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetPrivateendport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["privateendport"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetPrivateport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["privateport"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetProtocol(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["protocol"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetPublicendport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["publicendport"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetPublicport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["publicport"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetVirtualmachineid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["virtualmachineid"] = v
return
}
func (p *CreatePortForwardingRuleParams) SetVmguestip(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["vmguestip"] = v
return
}
// You should always use this function to get a new CreatePortForwardingRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewCreatePortForwardingRuleParams(ipaddressid string, privateport int, protocol string, publicport int, virtualmachineid string) *CreatePortForwardingRuleParams {
p := &CreatePortForwardingRuleParams{}
p.p = make(map[string]interface{})
p.p["ipaddressid"] = ipaddressid
p.p["privateport"] = privateport
p.p["protocol"] = protocol
p.p["publicport"] = publicport
p.p["virtualmachineid"] = virtualmachineid
return p
}
// Creates a port forwarding rule
func (s *FirewallService) CreatePortForwardingRule(p *CreatePortForwardingRuleParams) (*CreatePortForwardingRuleResponse, error) {
resp, err := s.cs.newRequest("createPortForwardingRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r CreatePortForwardingRuleResponse
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
}
b, err = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type CreatePortForwardingRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Cidrlist string `json:"cidrlist,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Privateendport string `json:"privateendport,omitempty"`
Privateport string `json:"privateport,omitempty"`
Protocol string `json:"protocol,omitempty"`
Publicendport string `json:"publicendport,omitempty"`
Publicport string `json:"publicport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
Virtualmachinedisplayname string `json:"virtualmachinedisplayname,omitempty"`
Virtualmachineid string `json:"virtualmachineid,omitempty"`
Virtualmachinename string `json:"virtualmachinename,omitempty"`
Vmguestip string `json:"vmguestip,omitempty"`
}
type DeletePortForwardingRuleParams struct {
p map[string]interface{}
}
func (p *DeletePortForwardingRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
return u
}
func (p *DeletePortForwardingRuleParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
// You should always use this function to get a new DeletePortForwardingRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewDeletePortForwardingRuleParams(id string) *DeletePortForwardingRuleParams {
p := &DeletePortForwardingRuleParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
// Deletes a port forwarding rule
func (s *FirewallService) DeletePortForwardingRule(p *DeletePortForwardingRuleParams) (*DeletePortForwardingRuleResponse, error) {
resp, err := s.cs.newRequest("deletePortForwardingRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r DeletePortForwardingRuleResponse
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 = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type DeletePortForwardingRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Displaytext string `json:"displaytext,omitempty"`
Success bool `json:"success,omitempty"`
}
type UpdatePortForwardingRuleParams struct {
p map[string]interface{}
}
func (p *UpdatePortForwardingRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["customid"]; found {
u.Set("customid", v.(string))
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
if v, found := p.p["privateport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("privateport", vv)
}
if v, found := p.p["virtualmachineid"]; found {
u.Set("virtualmachineid", v.(string))
}
if v, found := p.p["vmguestip"]; found {
u.Set("vmguestip", v.(string))
}
return u
}
func (p *UpdatePortForwardingRuleParams) SetCustomid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["customid"] = v
return
}
func (p *UpdatePortForwardingRuleParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *UpdatePortForwardingRuleParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
func (p *UpdatePortForwardingRuleParams) SetPrivateport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["privateport"] = v
return
}
func (p *UpdatePortForwardingRuleParams) SetVirtualmachineid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["virtualmachineid"] = v
return
}
func (p *UpdatePortForwardingRuleParams) SetVmguestip(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["vmguestip"] = v
return
}
// You should always use this function to get a new UpdatePortForwardingRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewUpdatePortForwardingRuleParams(id string) *UpdatePortForwardingRuleParams {
p := &UpdatePortForwardingRuleParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
// Updates a port forwarding rule. Only the private port and the virtual machine can be updated.
func (s *FirewallService) UpdatePortForwardingRule(p *UpdatePortForwardingRuleParams) (*UpdatePortForwardingRuleResponse, error) {
resp, err := s.cs.newRequest("updatePortForwardingRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r UpdatePortForwardingRuleResponse
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
}
b, err = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type UpdatePortForwardingRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Cidrlist string `json:"cidrlist,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Privateendport string `json:"privateendport,omitempty"`
Privateport string `json:"privateport,omitempty"`
Protocol string `json:"protocol,omitempty"`
Publicendport string `json:"publicendport,omitempty"`
Publicport string `json:"publicport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
Virtualmachinedisplayname string `json:"virtualmachinedisplayname,omitempty"`
Virtualmachineid string `json:"virtualmachineid,omitempty"`
Virtualmachinename string `json:"virtualmachinename,omitempty"`
Vmguestip string `json:"vmguestip,omitempty"`
}
type CreateFirewallRuleParams struct {
p map[string]interface{}
}
func (p *CreateFirewallRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["cidrlist"]; found {
vv := strings.Join(v.([]string), ",")
u.Set("cidrlist", vv)
}
if v, found := p.p["endport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("endport", vv)
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["icmpcode"]; found {
vv := strconv.Itoa(v.(int))
u.Set("icmpcode", vv)
}
if v, found := p.p["icmptype"]; found {
vv := strconv.Itoa(v.(int))
u.Set("icmptype", vv)
}
if v, found := p.p["ipaddressid"]; found {
u.Set("ipaddressid", v.(string))
}
if v, found := p.p["protocol"]; found {
u.Set("protocol", v.(string))
}
if v, found := p.p["startport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("startport", vv)
}
if v, found := p.p["type"]; found {
u.Set("type", v.(string))
}
return u
}
func (p *CreateFirewallRuleParams) SetCidrlist(v []string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["cidrlist"] = v
return
}
func (p *CreateFirewallRuleParams) SetEndport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["endport"] = v
return
}
func (p *CreateFirewallRuleParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *CreateFirewallRuleParams) SetIcmpcode(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["icmpcode"] = v
return
}
func (p *CreateFirewallRuleParams) SetIcmptype(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["icmptype"] = v
return
}
func (p *CreateFirewallRuleParams) SetIpaddressid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["ipaddressid"] = v
return
}
func (p *CreateFirewallRuleParams) SetProtocol(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["protocol"] = v
return
}
func (p *CreateFirewallRuleParams) SetStartport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["startport"] = v
return
}
func (p *CreateFirewallRuleParams) SetType(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["firewallType"] = v
return
}
// You should always use this function to get a new CreateFirewallRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewCreateFirewallRuleParams(ipaddressid string, protocol string) *CreateFirewallRuleParams {
p := &CreateFirewallRuleParams{}
p.p = make(map[string]interface{})
p.p["ipaddressid"] = ipaddressid
p.p["protocol"] = protocol
return p
}
// Creates a firewall rule for a given IP address
func (s *FirewallService) CreateFirewallRule(p *CreateFirewallRuleParams) (*CreateFirewallRuleResponse, error) {
resp, err := s.cs.newRequest("createFirewallRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r CreateFirewallRuleResponse
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
}
b, err = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type CreateFirewallRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Cidrlist string `json:"cidrlist,omitempty"`
Endport int `json:"endport,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Icmpcode int `json:"icmpcode,omitempty"`
Icmptype int `json:"icmptype,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Protocol string `json:"protocol,omitempty"`
Startport int `json:"startport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
}
type DeleteFirewallRuleParams struct {
p map[string]interface{}
}
func (p *DeleteFirewallRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
return u
}
func (p *DeleteFirewallRuleParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
// You should always use this function to get a new DeleteFirewallRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewDeleteFirewallRuleParams(id string) *DeleteFirewallRuleParams {
p := &DeleteFirewallRuleParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
// Deletes a firewall rule
func (s *FirewallService) DeleteFirewallRule(p *DeleteFirewallRuleParams) (*DeleteFirewallRuleResponse, error) {
resp, err := s.cs.newRequest("deleteFirewallRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r DeleteFirewallRuleResponse
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 = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type DeleteFirewallRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Displaytext string `json:"displaytext,omitempty"`
Success bool `json:"success,omitempty"`
}
type ListFirewallRulesParams struct {
p map[string]interface{}
}
func (p *ListFirewallRulesParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["account"]; found {
u.Set("account", v.(string))
}
if v, found := p.p["domainid"]; found {
u.Set("domainid", v.(string))
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
if v, found := p.p["ipaddressid"]; found {
u.Set("ipaddressid", v.(string))
}
if v, found := p.p["isrecursive"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("isrecursive", vv)
}
if v, found := p.p["keyword"]; found {
u.Set("keyword", v.(string))
}
if v, found := p.p["listall"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("listall", vv)
}
if v, found := p.p["networkid"]; found {
u.Set("networkid", v.(string))
}
if v, found := p.p["page"]; found {
vv := strconv.Itoa(v.(int))
u.Set("page", vv)
}
if v, found := p.p["pagesize"]; found {
vv := strconv.Itoa(v.(int))
u.Set("pagesize", vv)
}
if v, found := p.p["projectid"]; found {
u.Set("projectid", v.(string))
}
if v, found := p.p["tags"]; found {
i := 0
for k, vv := range v.(map[string]string) {
u.Set(fmt.Sprintf("tags[%d].key", i), k)
u.Set(fmt.Sprintf("tags[%d].value", i), vv)
i++
}
}
return u
}
func (p *ListFirewallRulesParams) SetAccount(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["account"] = v
return
}
func (p *ListFirewallRulesParams) SetDomainid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["domainid"] = v
return
}
func (p *ListFirewallRulesParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *ListFirewallRulesParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
func (p *ListFirewallRulesParams) SetIpaddressid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["ipaddressid"] = v
return
}
func (p *ListFirewallRulesParams) SetIsrecursive(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["isrecursive"] = v
return
}
func (p *ListFirewallRulesParams) SetKeyword(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["keyword"] = v
return
}
func (p *ListFirewallRulesParams) SetListall(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["listall"] = v
return
}
func (p *ListFirewallRulesParams) SetNetworkid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["networkid"] = v
return
}
func (p *ListFirewallRulesParams) SetPage(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["page"] = v
return
}
func (p *ListFirewallRulesParams) SetPagesize(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["pagesize"] = v
return
}
func (p *ListFirewallRulesParams) SetProjectid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["projectid"] = v
return
}
func (p *ListFirewallRulesParams) SetTags(v map[string]string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["tags"] = v
return
}
// You should always use this function to get a new ListFirewallRulesParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewListFirewallRulesParams() *ListFirewallRulesParams {
p := &ListFirewallRulesParams{}
p.p = make(map[string]interface{})
return p
}
// This is a courtesy helper function, which in some cases may not work as expected!
func (s *FirewallService) GetFirewallRuleByID(id string, opts ...OptionFunc) (*FirewallRule, int, error) {
p := &ListFirewallRulesParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
for _, fn := range opts {
if err := fn(s.cs, p); err != nil {
return nil, -1, err
}
}
l, err := s.ListFirewallRules(p)
if err != nil {
if strings.Contains(err.Error(), fmt.Sprintf(
"Invalid parameter id value=%s due to incorrect long value format, "+
"or entity does not exist", id)) {
return nil, 0, fmt.Errorf("No match found for %s: %+v", id, l)
}
return nil, -1, err
}
if l.Count == 0 {
return nil, l.Count, fmt.Errorf("No match found for %s: %+v", id, l)
}
if l.Count == 1 {
return l.FirewallRules[0], l.Count, nil
}
return nil, l.Count, fmt.Errorf("There is more then one result for FirewallRule UUID: %s!", id)
}
// Lists all firewall rules for an IP address.
func (s *FirewallService) ListFirewallRules(p *ListFirewallRulesParams) (*ListFirewallRulesResponse, error) {
resp, err := s.cs.newRequest("listFirewallRules", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r ListFirewallRulesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
type ListFirewallRulesResponse struct {
Count int `json:"count"`
FirewallRules []*FirewallRule `json:"firewallrule"`
}
type FirewallRule struct {
Cidrlist string `json:"cidrlist,omitempty"`
Endport int `json:"endport,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Icmpcode int `json:"icmpcode,omitempty"`
Icmptype int `json:"icmptype,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Protocol string `json:"protocol,omitempty"`
Startport int `json:"startport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
}
type UpdateFirewallRuleParams struct {
p map[string]interface{}
}
func (p *UpdateFirewallRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["customid"]; found {
u.Set("customid", v.(string))
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
return u
}
func (p *UpdateFirewallRuleParams) SetCustomid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["customid"] = v
return
}
func (p *UpdateFirewallRuleParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *UpdateFirewallRuleParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
// You should always use this function to get a new UpdateFirewallRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewUpdateFirewallRuleParams(id string) *UpdateFirewallRuleParams {
p := &UpdateFirewallRuleParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
// Updates firewall rule
func (s *FirewallService) UpdateFirewallRule(p *UpdateFirewallRuleParams) (*UpdateFirewallRuleResponse, error) {
resp, err := s.cs.newRequest("updateFirewallRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r UpdateFirewallRuleResponse
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
}
b, err = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type UpdateFirewallRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Cidrlist string `json:"cidrlist,omitempty"`
Endport int `json:"endport,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Icmpcode int `json:"icmpcode,omitempty"`
Icmptype int `json:"icmptype,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Protocol string `json:"protocol,omitempty"`
Startport int `json:"startport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
}
type CreateEgressFirewallRuleParams struct {
p map[string]interface{}
}
func (p *CreateEgressFirewallRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["cidrlist"]; found {
vv := strings.Join(v.([]string), ",")
u.Set("cidrlist", vv)
}
if v, found := p.p["endport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("endport", vv)
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["icmpcode"]; found {
vv := strconv.Itoa(v.(int))
u.Set("icmpcode", vv)
}
if v, found := p.p["icmptype"]; found {
vv := strconv.Itoa(v.(int))
u.Set("icmptype", vv)
}
if v, found := p.p["networkid"]; found {
u.Set("networkid", v.(string))
}
if v, found := p.p["protocol"]; found {
u.Set("protocol", v.(string))
}
if v, found := p.p["startport"]; found {
vv := strconv.Itoa(v.(int))
u.Set("startport", vv)
}
if v, found := p.p["type"]; found {
u.Set("type", v.(string))
}
return u
}
func (p *CreateEgressFirewallRuleParams) SetCidrlist(v []string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["cidrlist"] = v
return
}
func (p *CreateEgressFirewallRuleParams) SetEndport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["endport"] = v
return
}
func (p *CreateEgressFirewallRuleParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *CreateEgressFirewallRuleParams) SetIcmpcode(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["icmpcode"] = v
return
}
func (p *CreateEgressFirewallRuleParams) SetIcmptype(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["icmptype"] = v
return
}
func (p *CreateEgressFirewallRuleParams) SetNetworkid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["networkid"] = v
return
}
func (p *CreateEgressFirewallRuleParams) SetProtocol(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["protocol"] = v
return
}
func (p *CreateEgressFirewallRuleParams) SetStartport(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["startport"] = v
return
}
func (p *CreateEgressFirewallRuleParams) SetType(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["firewallType"] = v
return
}
// You should always use this function to get a new CreateEgressFirewallRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewCreateEgressFirewallRuleParams(networkid string, protocol string) *CreateEgressFirewallRuleParams {
p := &CreateEgressFirewallRuleParams{}
p.p = make(map[string]interface{})
p.p["networkid"] = networkid
p.p["protocol"] = protocol
return p
}
// Creates a egress firewall rule for a given network
func (s *FirewallService) CreateEgressFirewallRule(p *CreateEgressFirewallRuleParams) (*CreateEgressFirewallRuleResponse, error) {
resp, err := s.cs.newRequest("createEgressFirewallRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r CreateEgressFirewallRuleResponse
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
}
b, err = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type CreateEgressFirewallRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Cidrlist string `json:"cidrlist,omitempty"`
Endport int `json:"endport,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Icmpcode int `json:"icmpcode,omitempty"`
Icmptype int `json:"icmptype,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Protocol string `json:"protocol,omitempty"`
Startport int `json:"startport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
}
type DeleteEgressFirewallRuleParams struct {
p map[string]interface{}
}
func (p *DeleteEgressFirewallRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
return u
}
func (p *DeleteEgressFirewallRuleParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
// You should always use this function to get a new DeleteEgressFirewallRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewDeleteEgressFirewallRuleParams(id string) *DeleteEgressFirewallRuleParams {
p := &DeleteEgressFirewallRuleParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
// Deletes an egress firewall rule
func (s *FirewallService) DeleteEgressFirewallRule(p *DeleteEgressFirewallRuleParams) (*DeleteEgressFirewallRuleResponse, error) {
resp, err := s.cs.newRequest("deleteEgressFirewallRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r DeleteEgressFirewallRuleResponse
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 = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type DeleteEgressFirewallRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Displaytext string `json:"displaytext,omitempty"`
Success bool `json:"success,omitempty"`
}
type ListEgressFirewallRulesParams struct {
p map[string]interface{}
}
func (p *ListEgressFirewallRulesParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["account"]; found {
u.Set("account", v.(string))
}
if v, found := p.p["domainid"]; found {
u.Set("domainid", v.(string))
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
if v, found := p.p["ipaddressid"]; found {
u.Set("ipaddressid", v.(string))
}
if v, found := p.p["isrecursive"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("isrecursive", vv)
}
if v, found := p.p["keyword"]; found {
u.Set("keyword", v.(string))
}
if v, found := p.p["listall"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("listall", vv)
}
if v, found := p.p["networkid"]; found {
u.Set("networkid", v.(string))
}
if v, found := p.p["page"]; found {
vv := strconv.Itoa(v.(int))
u.Set("page", vv)
}
if v, found := p.p["pagesize"]; found {
vv := strconv.Itoa(v.(int))
u.Set("pagesize", vv)
}
if v, found := p.p["projectid"]; found {
u.Set("projectid", v.(string))
}
if v, found := p.p["tags"]; found {
i := 0
for k, vv := range v.(map[string]string) {
u.Set(fmt.Sprintf("tags[%d].key", i), k)
u.Set(fmt.Sprintf("tags[%d].value", i), vv)
i++
}
}
return u
}
func (p *ListEgressFirewallRulesParams) SetAccount(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["account"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetDomainid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["domainid"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetIpaddressid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["ipaddressid"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetIsrecursive(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["isrecursive"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetKeyword(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["keyword"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetListall(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["listall"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetNetworkid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["networkid"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetPage(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["page"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetPagesize(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["pagesize"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetProjectid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["projectid"] = v
return
}
func (p *ListEgressFirewallRulesParams) SetTags(v map[string]string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["tags"] = v
return
}
// You should always use this function to get a new ListEgressFirewallRulesParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewListEgressFirewallRulesParams() *ListEgressFirewallRulesParams {
p := &ListEgressFirewallRulesParams{}
p.p = make(map[string]interface{})
return p
}
// This is a courtesy helper function, which in some cases may not work as expected!
func (s *FirewallService) GetEgressFirewallRuleByID(id string, opts ...OptionFunc) (*EgressFirewallRule, int, error) {
p := &ListEgressFirewallRulesParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
for _, fn := range opts {
if err := fn(s.cs, p); err != nil {
return nil, -1, err
}
}
l, err := s.ListEgressFirewallRules(p)
if err != nil {
if strings.Contains(err.Error(), fmt.Sprintf(
"Invalid parameter id value=%s due to incorrect long value format, "+
"or entity does not exist", id)) {
return nil, 0, fmt.Errorf("No match found for %s: %+v", id, l)
}
return nil, -1, err
}
if l.Count == 0 {
return nil, l.Count, fmt.Errorf("No match found for %s: %+v", id, l)
}
if l.Count == 1 {
return l.EgressFirewallRules[0], l.Count, nil
}
return nil, l.Count, fmt.Errorf("There is more then one result for EgressFirewallRule UUID: %s!", id)
}
// Lists all egress firewall rules for network ID.
func (s *FirewallService) ListEgressFirewallRules(p *ListEgressFirewallRulesParams) (*ListEgressFirewallRulesResponse, error) {
resp, err := s.cs.newRequest("listEgressFirewallRules", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r ListEgressFirewallRulesResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
type ListEgressFirewallRulesResponse struct {
Count int `json:"count"`
EgressFirewallRules []*EgressFirewallRule `json:"firewallrule"`
}
type EgressFirewallRule struct {
Cidrlist string `json:"cidrlist,omitempty"`
Endport int `json:"endport,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Icmpcode int `json:"icmpcode,omitempty"`
Icmptype int `json:"icmptype,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Protocol string `json:"protocol,omitempty"`
Startport int `json:"startport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
}
type UpdateEgressFirewallRuleParams struct {
p map[string]interface{}
}
func (p *UpdateEgressFirewallRuleParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["customid"]; found {
u.Set("customid", v.(string))
}
if v, found := p.p["fordisplay"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("fordisplay", vv)
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
return u
}
func (p *UpdateEgressFirewallRuleParams) SetCustomid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["customid"] = v
return
}
func (p *UpdateEgressFirewallRuleParams) SetFordisplay(v bool) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fordisplay"] = v
return
}
func (p *UpdateEgressFirewallRuleParams) SetId(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["id"] = v
return
}
// You should always use this function to get a new UpdateEgressFirewallRuleParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewUpdateEgressFirewallRuleParams(id string) *UpdateEgressFirewallRuleParams {
p := &UpdateEgressFirewallRuleParams{}
p.p = make(map[string]interface{})
p.p["id"] = id
return p
}
// Updates egress firewall rule
func (s *FirewallService) UpdateEgressFirewallRule(p *UpdateEgressFirewallRuleParams) (*UpdateEgressFirewallRuleResponse, error) {
resp, err := s.cs.newRequest("updateEgressFirewallRule", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r UpdateEgressFirewallRuleResponse
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
}
b, err = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type UpdateEgressFirewallRuleResponse struct {
JobID string `json:"jobid,omitempty"`
Cidrlist string `json:"cidrlist,omitempty"`
Endport int `json:"endport,omitempty"`
Fordisplay bool `json:"fordisplay,omitempty"`
Icmpcode int `json:"icmpcode,omitempty"`
Icmptype int `json:"icmptype,omitempty"`
Id string `json:"id,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Ipaddressid string `json:"ipaddressid,omitempty"`
Networkid string `json:"networkid,omitempty"`
Protocol string `json:"protocol,omitempty"`
Startport int `json:"startport,omitempty"`
State string `json:"state,omitempty"`
Tags []struct {
Account string `json:"account,omitempty"`
Customer string `json:"customer,omitempty"`
Domain string `json:"domain,omitempty"`
Domainid string `json:"domainid,omitempty"`
Key string `json:"key,omitempty"`
Project string `json:"project,omitempty"`
Projectid string `json:"projectid,omitempty"`
Resourceid string `json:"resourceid,omitempty"`
Resourcetype string `json:"resourcetype,omitempty"`
Value string `json:"value,omitempty"`
} `json:"tags,omitempty"`
}
type AddPaloAltoFirewallParams struct {
p map[string]interface{}
}
func (p *AddPaloAltoFirewallParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["networkdevicetype"]; found {
u.Set("networkdevicetype", v.(string))
}
if v, found := p.p["password"]; found {
u.Set("password", v.(string))
}
if v, found := p.p["physicalnetworkid"]; found {
u.Set("physicalnetworkid", v.(string))
}
if v, found := p.p["url"]; found {
u.Set("url", v.(string))
}
if v, found := p.p["username"]; found {
u.Set("username", v.(string))
}
return u
}
func (p *AddPaloAltoFirewallParams) SetNetworkdevicetype(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["networkdevicetype"] = v
return
}
func (p *AddPaloAltoFirewallParams) SetPassword(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["password"] = v
return
}
func (p *AddPaloAltoFirewallParams) SetPhysicalnetworkid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["physicalnetworkid"] = v
return
}
func (p *AddPaloAltoFirewallParams) SetUrl(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["url"] = v
return
}
func (p *AddPaloAltoFirewallParams) SetUsername(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["username"] = v
return
}
// You should always use this function to get a new AddPaloAltoFirewallParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewAddPaloAltoFirewallParams(networkdevicetype string, password string, physicalnetworkid string, url string, username string) *AddPaloAltoFirewallParams {
p := &AddPaloAltoFirewallParams{}
p.p = make(map[string]interface{})
p.p["networkdevicetype"] = networkdevicetype
p.p["password"] = password
p.p["physicalnetworkid"] = physicalnetworkid
p.p["url"] = url
p.p["username"] = username
return p
}
// Adds a Palo Alto firewall device
func (s *FirewallService) AddPaloAltoFirewall(p *AddPaloAltoFirewallParams) (*AddPaloAltoFirewallResponse, error) {
resp, err := s.cs.newRequest("addPaloAltoFirewall", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r AddPaloAltoFirewallResponse
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
}
b, err = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type AddPaloAltoFirewallResponse struct {
JobID string `json:"jobid,omitempty"`
Fwdevicecapacity int64 `json:"fwdevicecapacity,omitempty"`
Fwdeviceid string `json:"fwdeviceid,omitempty"`
Fwdevicename string `json:"fwdevicename,omitempty"`
Fwdevicestate string `json:"fwdevicestate,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Numretries string `json:"numretries,omitempty"`
Physicalnetworkid string `json:"physicalnetworkid,omitempty"`
Privateinterface string `json:"privateinterface,omitempty"`
Privatezone string `json:"privatezone,omitempty"`
Provider string `json:"provider,omitempty"`
Publicinterface string `json:"publicinterface,omitempty"`
Publiczone string `json:"publiczone,omitempty"`
Timeout string `json:"timeout,omitempty"`
Usageinterface string `json:"usageinterface,omitempty"`
Username string `json:"username,omitempty"`
Zoneid string `json:"zoneid,omitempty"`
}
type DeletePaloAltoFirewallParams struct {
p map[string]interface{}
}
func (p *DeletePaloAltoFirewallParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["fwdeviceid"]; found {
u.Set("fwdeviceid", v.(string))
}
return u
}
func (p *DeletePaloAltoFirewallParams) SetFwdeviceid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fwdeviceid"] = v
return
}
// You should always use this function to get a new DeletePaloAltoFirewallParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewDeletePaloAltoFirewallParams(fwdeviceid string) *DeletePaloAltoFirewallParams {
p := &DeletePaloAltoFirewallParams{}
p.p = make(map[string]interface{})
p.p["fwdeviceid"] = fwdeviceid
return p
}
// delete a Palo Alto firewall device
func (s *FirewallService) DeletePaloAltoFirewall(p *DeletePaloAltoFirewallParams) (*DeletePaloAltoFirewallResponse, error) {
resp, err := s.cs.newRequest("deletePaloAltoFirewall", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r DeletePaloAltoFirewallResponse
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 = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type DeletePaloAltoFirewallResponse struct {
JobID string `json:"jobid,omitempty"`
Displaytext string `json:"displaytext,omitempty"`
Success bool `json:"success,omitempty"`
}
type ConfigurePaloAltoFirewallParams struct {
p map[string]interface{}
}
func (p *ConfigurePaloAltoFirewallParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["fwdevicecapacity"]; found {
vv := strconv.FormatInt(v.(int64), 10)
u.Set("fwdevicecapacity", vv)
}
if v, found := p.p["fwdeviceid"]; found {
u.Set("fwdeviceid", v.(string))
}
return u
}
func (p *ConfigurePaloAltoFirewallParams) SetFwdevicecapacity(v int64) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fwdevicecapacity"] = v
return
}
func (p *ConfigurePaloAltoFirewallParams) SetFwdeviceid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fwdeviceid"] = v
return
}
// You should always use this function to get a new ConfigurePaloAltoFirewallParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewConfigurePaloAltoFirewallParams(fwdeviceid string) *ConfigurePaloAltoFirewallParams {
p := &ConfigurePaloAltoFirewallParams{}
p.p = make(map[string]interface{})
p.p["fwdeviceid"] = fwdeviceid
return p
}
// Configures a Palo Alto firewall device
func (s *FirewallService) ConfigurePaloAltoFirewall(p *ConfigurePaloAltoFirewallParams) (*ConfigurePaloAltoFirewallResponse, error) {
resp, err := s.cs.newRequest("configurePaloAltoFirewall", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r ConfigurePaloAltoFirewallResponse
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
}
b, err = convertFirewallServiceResponse(b)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &r); err != nil {
return nil, err
}
}
return &r, nil
}
type ConfigurePaloAltoFirewallResponse struct {
JobID string `json:"jobid,omitempty"`
Fwdevicecapacity int64 `json:"fwdevicecapacity,omitempty"`
Fwdeviceid string `json:"fwdeviceid,omitempty"`
Fwdevicename string `json:"fwdevicename,omitempty"`
Fwdevicestate string `json:"fwdevicestate,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Numretries string `json:"numretries,omitempty"`
Physicalnetworkid string `json:"physicalnetworkid,omitempty"`
Privateinterface string `json:"privateinterface,omitempty"`
Privatezone string `json:"privatezone,omitempty"`
Provider string `json:"provider,omitempty"`
Publicinterface string `json:"publicinterface,omitempty"`
Publiczone string `json:"publiczone,omitempty"`
Timeout string `json:"timeout,omitempty"`
Usageinterface string `json:"usageinterface,omitempty"`
Username string `json:"username,omitempty"`
Zoneid string `json:"zoneid,omitempty"`
}
type ListPaloAltoFirewallsParams struct {
p map[string]interface{}
}
func (p *ListPaloAltoFirewallsParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["fwdeviceid"]; found {
u.Set("fwdeviceid", v.(string))
}
if v, found := p.p["keyword"]; found {
u.Set("keyword", v.(string))
}
if v, found := p.p["page"]; found {
vv := strconv.Itoa(v.(int))
u.Set("page", vv)
}
if v, found := p.p["pagesize"]; found {
vv := strconv.Itoa(v.(int))
u.Set("pagesize", vv)
}
if v, found := p.p["physicalnetworkid"]; found {
u.Set("physicalnetworkid", v.(string))
}
return u
}
func (p *ListPaloAltoFirewallsParams) SetFwdeviceid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["fwdeviceid"] = v
return
}
func (p *ListPaloAltoFirewallsParams) SetKeyword(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["keyword"] = v
return
}
func (p *ListPaloAltoFirewallsParams) SetPage(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["page"] = v
return
}
func (p *ListPaloAltoFirewallsParams) SetPagesize(v int) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["pagesize"] = v
return
}
func (p *ListPaloAltoFirewallsParams) SetPhysicalnetworkid(v string) {
if p.p == nil {
p.p = make(map[string]interface{})
}
p.p["physicalnetworkid"] = v
return
}
// You should always use this function to get a new ListPaloAltoFirewallsParams instance,
// as then you are sure you have configured all required params
func (s *FirewallService) NewListPaloAltoFirewallsParams() *ListPaloAltoFirewallsParams {
p := &ListPaloAltoFirewallsParams{}
p.p = make(map[string]interface{})
return p
}
// lists Palo Alto firewall devices in a physical network
func (s *FirewallService) ListPaloAltoFirewalls(p *ListPaloAltoFirewallsParams) (*ListPaloAltoFirewallsResponse, error) {
resp, err := s.cs.newRequest("listPaloAltoFirewalls", p.toURLValues())
if err != nil {
return nil, err
}
resp, err = convertFirewallServiceResponse(resp)
if err != nil {
return nil, err
}
var r ListPaloAltoFirewallsResponse
if err := json.Unmarshal(resp, &r); err != nil {
return nil, err
}
return &r, nil
}
type ListPaloAltoFirewallsResponse struct {
Count int `json:"count"`
PaloAltoFirewalls []*PaloAltoFirewall `json:"paloaltofirewall"`
}
type PaloAltoFirewall struct {
Fwdevicecapacity int64 `json:"fwdevicecapacity,omitempty"`
Fwdeviceid string `json:"fwdeviceid,omitempty"`
Fwdevicename string `json:"fwdevicename,omitempty"`
Fwdevicestate string `json:"fwdevicestate,omitempty"`
Ipaddress string `json:"ipaddress,omitempty"`
Numretries string `json:"numretries,omitempty"`
Physicalnetworkid string `json:"physicalnetworkid,omitempty"`
Privateinterface string `json:"privateinterface,omitempty"`
Privatezone string `json:"privatezone,omitempty"`
Provider string `json:"provider,omitempty"`
Publicinterface string `json:"publicinterface,omitempty"`
Publiczone string `json:"publiczone,omitempty"`
Timeout string `json:"timeout,omitempty"`
Usageinterface string `json:"usageinterface,omitempty"`
Username string `json:"username,omitempty"`
Zoneid string `json:"zoneid,omitempty"`
}